diff --git a/nonmatching/game/func_0046CEA0.c b/nonmatching/game/func_0046CEA0.c
deleted file mode 100644
index 85b953573..000000000
--- a/nonmatching/game/func_0046CEA0.c
+++ /dev/null
@@ -1,87 +0,0 @@
-/* Not matching yet: BYTES 57/552 (tools/try_func.py func_0046CEA0 --diff). Not part of the build. */
-#include "common.h"
-
-typedef struct {
-    s32 f0;
-    s32 f4;
-    s32 f8;
-    s32 fC;
-} Type1;
-
-typedef struct {
-    Type1 *f0;
-    u32 f4;
-} Type2;
-
-extern void func_004537D0(s32 *, s32 *, s32);
-extern s32 D_003D82F0[];
-extern s32 D_003DA6B0[];
-extern Type2 *D_0022144C;
-extern Type1 *D_00221E20;
-extern Type2 D_00265D60[];
-
-void func_0046CEA0(void) {
-    Type1 *head;
-    Type2 *e;
-    Type1 *pkt;
-    u32 tag;
-    u8 *info;
-    u32 w;
-    u32 n;
-    u8 *base;
-    s16 *src;
-    u8 *dst;
-    u32 stride;
-    s32 tagv;
-    u32 lo;
-    s16 v;
-
-    if (D_0022144C != D_00265D60) {
-        head = D_00221E20++;
-        e = D_00265D60;
-        if (e < D_0022144C) {
-            tagv = 0x20000000;
-            do {
-                pkt = e->f0;
-                tag = e->f4;
-                lo = tag & 0xF;
-                ((s32 *)pkt)[0] = tagv;
-                ((s32 *)pkt)[3] = 0x11000000;
-                ((s32 *)pkt)[1] = (s32)D_00221E20;
-                info = *(u8 **)((tag & ~0xF) + 0x24);
-                w = info[0xB] & 0xF;
-                n = info[0xB] >> 4;
-                base = *(u8 **)(info + 0x20) - ((w * n) << 10) - 0x10;
-                if (n != 0) {
-                    src = (s16 *)base;
-                    dst = base + ((lo << 10) + 0x10);
-                    stride = w << 10;
-                    do {
-                        v = *src++;
-                        func_004537D0((s32 *)D_00221E20, D_003D82F0, 0x70);
-                        n--;
-                        *(s16 *)((u8 *)D_00221E20 + 0x24) = v;
-                        *(u8 **)((u8 *)D_00221E20 + 0x64) = dst;
-                        dst += stride;
-                        D_00221E20 += 7;
-                    } while (n != 0);
-                }
-                ((s32 *)D_00221E20)[0] = 0x30000003;
-                ((s32 *)D_00221E20)[1] = (s32)D_003DA6B0;
-                ((s32 *)D_00221E20)[2] = 0;
-                ((s32 *)D_00221E20)[3] = 0x50000003;
-                D_00221E20++;
-                ((s32 *)D_00221E20)[0] = tagv;
-                ((s32 *)D_00221E20)[1] = (s32)(pkt + 1);
-                ((s32 *)D_00221E20)[2] = 0;
-                ((s32 *)D_00221E20)[3] = 0;
-                D_00221E20++;
-                e++;
-            } while (e < D_0022144C);
-        }
-        ((s32 *)head)[0] = 0x20000000;
-        ((s32 *)head)[1] = (s32)D_00221E20;
-        ((s32 *)head)[2] = 0;
-        ((s32 *)head)[3] = 0;
-    }
-}
diff --git a/nonmatching/game/func_0046E9E8.c b/nonmatching/game/func_0046E9E8.c
deleted file mode 100644
index 9f25a862f..000000000
--- a/nonmatching/game/func_0046E9E8.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/* Not matching yet: BYTES 17/224 (tools/try_func.py func_0046E9E8 --diff). Not part of the build. */
-extern void func_004697C0(void *a0, s32 a1, s32 a2);
-extern void func_00469800();
-extern void func_0046DC80(f32);
-
-// Splits a frame time into whole/fraction, submits the header and the two neighbouring frame blocks, then calls func_0046DC80 with the fraction.
-void func_0046E9E8(u8 *arg0, f32 t) {
-    s32 i = (s32)t;
-    s32 next = i + 1;
-    u8 *data;
-    s32 stride;
-    s32 hdr;
-    u8 *cur;
-    u8 *nxt;
-    f32 frac;
-
-    frac = t - (f32)i;
-    data = *(u8 **)(arg0 + 0x1C);
-    if (next == arg0[0x10]) next = 0;
-    stride = data[2];
-    hdr = data[1];
-    cur = data + (hdr + i * stride) * 16;
-    nxt = data + (next * stride + hdr) * 16;
-    if (hdr != 0) {
-        func_004697C0(data, hdr, 0x2000);
-        func_00469800();
-    }
-    if (stride != 0) {
-        func_004697C0(cur, stride, 0x3000);
-        func_00469800();
-        func_004697C0(nxt, stride, 0x3800);
-        func_00469800();
-    }
-    func_0046DC80(frac);
-}
diff --git a/nonmatching/game/func_004A06F8.c b/nonmatching/game/func_004A06F8.c
deleted file mode 100644
index d1ea93693..000000000
--- a/nonmatching/game/func_004A06F8.c
+++ /dev/null
@@ -1,82 +0,0 @@
-/* Not matching yet: BYTES 12/376 (tools/try_func.py func_004A06F8 --diff). Not part of the build. */
-#include "common.h"
-
-typedef struct Type2 {
-    s32 f0;
-    s32 f4;
-    s32 (*f8)(void *, s32);
-    void (*fC)(void *, s32);
-} Type2;
-
-typedef struct Type3 {
-    Type2 *f0;
-} Type3;
-
-typedef struct Type4 {
-    s32 f0;
-    s32 f4;
-    Type2 *f8;
-} Type4;
-
-typedef struct Type5 {
-    s32 f0[5];
-    s32 f14;
-} Type5;
-
-typedef struct Type1 {
-    s32 f0;
-    Type5 *f4;
-} Type1;
-
-extern Type1 D_00222038[];
-
-extern s32 func_0015DB80(s32, s32);
-extern s32 func_004FF910(s32, s32);
-extern s32 func_005005A8(s32, Type4 *, s32);
-extern Type1 *func_005010E0(void);
-extern Type3 *func_005011A8(Type1 *, s32);
-extern void func_00504228(s32);
-extern s32 func_00504230(void);
-extern Type4 *func_0050D2E8(s32);
-
-static inline Type1 *func_004A06F8_get(void) {
-    if (D_00222038->f4 != 0) {
-        return D_00222038;
-    }
-    return func_005010E0();
-}
-
-s32 func_004A06F8(s32 arg0) {
-    Type5 *q;
-    s32 s1;
-    s32 s0;
-    s32 s2;
-    s32 s3;
-    Type3 *obj;
-    Type4 *o;
-
-    s3 = 0;
-    q = func_004A06F8_get()->f4;
-    s1 = 0;
-    if (q != 0) {
-        s1 = q->f0[q->f14];
-    }
-    func_00504228(0x48);
-    s0 = func_00504230();
-    if (s1 != 0) {
-        if (func_004FF910(s1, arg0) == 0) {
-            obj = func_005011A8(func_004A06F8_get(), 1);
-            s2 = obj->f0->f8(obj, s0);
-            if (s2 != 0) {
-                o = func_0050D2E8(func_0015DB80(0x48, s2));
-                s3 = func_005005A8(s1, o, arg0) != 0;
-                if (s3 == 0) {
-                    o->f8->f8(o, 2);
-                    obj = func_005011A8(func_004A06F8_get(), 1);
-                    obj->f0->fC(obj, s2);
-                }
-            }
-        }
-    }
-    return s3;
-}
diff --git a/nonmatching/game/func_004A8280.c b/nonmatching/game/func_004A8280.c
deleted file mode 100644
index b34f372ad..000000000
--- a/nonmatching/game/func_004A8280.c
+++ /dev/null
@@ -1,37 +0,0 @@
-/* Not matching yet: BYTES 31/292 (tools/try_func.py func_004A8280 --diff). Not part of the build. */
-/* cflags: -O2 -fno-gcse */
-/* Note: the cflags above were a diagnostic experiment; a landable version must build with the file's normal flags. */
-#include "common.h"
-
-extern s32 func_00498670(void *a, s32 b, s32 c, f32 x);
-extern s32 func_00498918(s32, s32);
-extern s32 func_004989C0(s32 a0, s32 a1);
-extern s32 func_004A1A60(void *arg0, s32 arg1);
-extern void func_00505328(s32, s32);
-extern s32 func_00505B20(void);
-extern char D_00221650[];
-extern char D_00308108[];
-
-void func_004A8280(void)
-{
-    s32 color = 0x40000000;
-    s32 idx = func_00505B20();
-    char *p = D_00308108 + idx * 0xB8;
-    s32 n = *(s32 *)(p + 0xC);
-    s32 c;
-
-    if (n != 0) {
-        if (n > 0) {
-            c = func_00498918(0, 1);
-        } else {
-            c = func_00498918(1, 1);
-        }
-        color = func_00498670(p + 0x10, 0x40000000, (c & 0xFFFFFF) | 0x40000000, 0.01f);
-    }
-    func_00505328(func_004A1A60(D_00221650, 0x2C), color);
-    color = 0x80D0D0D0;
-    if (*(s32 *)(p + 0x74) <= 0 && *(s32 *)(p + 0x94) > 0) {
-        color = func_00498670(p + 0x14, func_004989C0(idx, 0), 0x80D0D0D0, 0.05f);
-    }
-    func_00505328(func_004A1A60(D_00221650, 0x30), color);
-}
diff --git a/nonmatching/game/func_004A8E78.c b/nonmatching/game/func_004A8E78.c
deleted file mode 100644
index 2e885bc37..000000000
--- a/nonmatching/game/func_004A8E78.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/* Not matching yet: BYTES 17/236 (tools/try_func.py func_004A8E78 --diff). Not part of the build. */
-#include "common.h"
-
-typedef struct {
-    u8 pad00[0x70];
-    s32 unk70;
-    s32 unk74;
-    s32 unk78;
-    u8 pad7C[0x3C];
-} Entry;
-
-extern s32 func_004A86E0(void);
-extern void func_004A8778(s32 arg0, s32 arg1);
-extern void func_004A89A0(s32 arg0, s32 arg1);
-extern s32 func_00505B20(void);
-extern void *func_00510BE8(s32 arg0);
-extern s32 func_00547E00(s32, s32);
-extern s32 func_00547E30(s32 arg0, s32 arg1);
-extern s32 func_00548018(s32 arg0);
-extern u8 *D_0021DFF0[];
-extern s32 D_0021EDD4[];
-extern Entry D_00308108[];
-
-void func_004A8E78(void) {
-    s32 idx = func_00505B20();
-    s32 b = func_004A86E0();
-    Entry *e = &D_00308108[idx];
-    u8 *obj = func_00510BE8(idx);
-    s32 v;
-    s32 w;
-
-    if (func_00548018(b) != 0) {
-        v = 0;
-    } else {
-        v = func_00547E30(*(s32 *)(obj + 0x26E4), b);
-    }
-    if (D_0021EDD4[0] == 1) {
-        if (*(s8 *)(D_0021DFF0[0] + 0x20) != 0) {
-            v = 0;
-        }
-    }
-    if (e->unk70 != v) {
-        e->unk70 = v;
-        func_004A8778(idx, v);
-    }
-    w = func_00547E00(*(s32 *)(obj + 0x26E4), b);
-    e->unk74 = w;
-    if (e->unk78 != w) {
-        e->unk78 = w;
-        func_004A89A0(idx, w);
-    }
-}
diff --git a/nonmatching/game/func_004B9440.c b/nonmatching/game/func_004B9440.c
deleted file mode 100644
index 8230fcc6a..000000000
--- a/nonmatching/game/func_004B9440.c
+++ /dev/null
@@ -1,40 +0,0 @@
-/* Not matching yet: BYTES 6/284 (tools/try_func.py func_004B9440 --diff). Not part of the build. */
-/* cflags: -G16 */
-/* Note: the cflags above were a diagnostic experiment; a landable version must build with the file's normal flags. */
-#include "common.h"
-
-typedef struct {
-    s32 unk0;
-    s32 unk4;
-    s32 unk8;
-    s32 unkC;
-} Type1;
-
-extern s32 func_0045E038(s32);
-extern s32 func_004A1A60(s32 *arg0, s32 arg1);
-extern s32 func_00505238(u32, s32);
-extern s32 func_00505B20(void);
-extern s32 D_003D9488[][13];
-extern s32 D_002217B0;
-extern Type1 D_002217B8[];
-
-s32 D_0021F8A0[4] = {0x2F1B, 0x2F19, 0x2F1A, 0};
-s32 D_0021F8B0[4] = {0x3163, 0x3164, 0x3165, 0};
-
-void func_004B9440(void) {
-    Type1 *p;
-    s32 h;
-    s32 i;
-
-    i = 0;
-    p = &D_002217B8[func_00505B20()];
-    h = func_004A1A60(&D_002217B0, 0x64);
-    func_00505238(h, func_0045E038(D_0021F8A0[p->unk4]));
-    do {
-        h = func_004A1A60(&D_002217B0, i + 0xB4);
-        func_00505238(h, func_0045E038(D_003D9488[p->unk4][i]));
-        i++;
-    } while (i < 13);
-    h = func_004A1A60(&D_002217B0, 0xB6);
-    func_00505238(h, func_0045E038(D_0021F8B0[p->unk8]));
-}
diff --git a/nonmatching/game/func_004C9090.c b/nonmatching/game/func_004C9090.c
deleted file mode 100644
index 87fd43f67..000000000
--- a/nonmatching/game/func_004C9090.c
+++ /dev/null
@@ -1,37 +0,0 @@
-/* Not matching yet: BYTES 3/216 (tools/try_func.py func_004C9090 --diff). Not part of the build. */
-extern s32 func_0045E038(s32);
-extern void func_00497980(s32 arg0);
-extern void func_0049E790(s32, s32, void (*)(void *), s32, f32, s32, s32, s32);
-extern void func_004C8FB0(void *);
-extern s32 func_004E6FA0(s32 *arg0);
-extern s32 func_00505B20(void);
-extern s32 D_30E494[];
-
-// checks the selected table entry and either finishes or queues a callback
-void func_004C9090(void) {
-    u8 *base;
-    u8 *entry;
-    s32 *obj;
-    s32 idx;
-    s32 a;
-
-    base = (u8 *)D_30E494;
-    if (*(s32 *)(base + 0x50) != 0) {
-        idx = *(s32 *)(base + 0x54);
-        entry = NULL;
-        if (idx >= 0) {
-            entry = *(u8 **)(base + 0x34) + idx * 0x18;
-        }
-        obj = *(s32 **)(entry + 8);
-        if (func_004E6FA0(obj) != 0) {
-            if (obj[2] <= 0 || obj[0] == 1) {
-                func_004C8FB0((void *)1);
-            } else {
-                a = func_00505B20();
-                func_0049E790(a, func_0045E038(0x8D0), func_004C8FB0, 3, -1.0f, 0, 0, 0);
-            }
-        } else {
-            func_00497980(4);
-        }
-    }
-}
diff --git a/nonmatching/game/func_004CBB98.c b/nonmatching/game/func_004CBB98.c
deleted file mode 100644
index 93821eeb8..000000000
--- a/nonmatching/game/func_004CBB98.c
+++ /dev/null
@@ -1,53 +0,0 @@
-/* Not matching yet: BYTES 8/628 (tools/try_func.py func_004CBB98 --diff). Not part of the build. */
-#include "common.h"
-
-extern void func_00498C98(void *arg0);
-extern s32 func_004A1A60(s32 *arg0, s32 arg1);
-extern s32 func_004CC978(void);
-extern void func_00504F68(s32, s32);
-extern void func_00505328(s32, s32);
-extern s32 func_005054F8(u32 id, s32 amount);
-extern void *func_00510BE8(s32 arg0);
-extern void *func_00548D28(s32 arg0, s32 arg1);
-extern s32 func_00548DA0();
-extern s32 D_003D2738[];
-extern s32 D_00221920;
-extern u8 D_0030EAA0[];
-
-void func_004CBB98(s32 arg0) {
-    s32 buf[6];
-    u8 *rec;
-    u8 *pl;
-    s32 h;
-    s32 h2;
-    s32 h3;
-
-    rec = D_0030EAA0 + arg0 * 100;
-    buf[0] = 5;
-    buf[1] = *(s32 *)(rec + 0x38);
-    func_00498C98(buf);
-    func_00505328(func_004A1A60(&D_00221920, D_003D2738[8]), 0x80808080);
-    func_005054F8(func_004A1A60(&D_00221920, D_003D2738[8]), buf[2]);
-    func_00504F68(func_004A1A60(&D_00221920, D_003D2738[8]), 1);
-    func_00505328(func_004A1A60(&D_00221920, D_003D2738[9]), 0x80808080);
-    h = func_004A1A60(&D_00221920, D_003D2738[9]);
-    func_005054F8(h, func_004CC978());
-    func_00504F68(func_004A1A60(&D_00221920, D_003D2738[9]), 1);
-    pl = func_00510BE8(arg0);
-    if (func_00548DA0(*(s32 *)(pl + 0x26E4), 0x11) != 0) {
-        func_00505328(func_004A1A60(&D_00221920, D_003D2738[10]), 0x80808080);
-        h2 = func_004A1A60(&D_00221920, D_003D2738[10]);
-        func_005054F8(h2, *(u16 *)((u8 *)func_00548D28(0x11, 0) + 0x36));
-        func_00504F68(func_004A1A60(&D_00221920, D_003D2738[10]), 1);
-    } else {
-        func_00504F68(func_004A1A60(&D_00221920, D_003D2738[10]), 0);
-    }
-    if (func_00548DA0(*(s32 *)(pl + 0x26E4), 0x12) != 0) {
-        func_00505328(func_004A1A60(&D_00221920, 0x33), 0x80808080);
-        h3 = func_004A1A60(&D_00221920, 0x33);
-        func_005054F8(h3, *(u16 *)((u8 *)func_00548D28(0x12, 0) + 0x36));
-        func_00504F68(func_004A1A60(&D_00221920, 0x33), 1);
-    } else {
-        func_00504F68(func_004A1A60(&D_00221920, D_003D2738[11]), 0);
-    }
-}
diff --git a/nonmatching/game/func_004D3060.c b/nonmatching/game/func_004D3060.c
deleted file mode 100644
index 69d416fec..000000000
--- a/nonmatching/game/func_004D3060.c
+++ /dev/null
@@ -1,51 +0,0 @@
-/* Not matching yet: BYTES 10/232 (tools/try_func.py func_004D3060 --diff). Not part of the build. */
-extern s32 func_00157F98(void);
-extern void func_00158868(s32 arg0);
-extern void func_0047EF38(void);
-extern void func_00489458(s32 arg0);
-extern void func_0048A060(s32 arg0, s32 arg1);
-extern void func_0048FA80(void *o);
-extern s32 func_0049B120(s32 index);
-extern void *func_004D36E0(void);
-extern s32 func_004E21D8(u32 index, s32 param_a, s32 param_b);
-extern void func_00501498(s32 *arg0);
-extern void func_00505AD8(s32 a);
-extern s32 func_00505B20(void);
-extern s32 func_00505C90(s32 arg0);
-extern void *D_0021DDCC;
-typedef struct {
-    s32 f0;
-    u8 pad4[0x4B];
-    u8 f4F;
-} Type1;
-extern Type1 D_003D9BE0[];
-extern s32 D_002214D0;
-u8 D_0021FB2C = 0;
-
-// Level/mode setup: reset several subsystems, store arg0 in D_003D9BE0 unless locked, and refresh.
-void func_004D3060(s32 arg0) {
-    s32 saved;
-
-    func_0047EF38();
-    func_00158868(0xCD);
-    if (func_0049B120(0) != 0x18) {
-        func_00489458(0);
-    }
-    func_0048A060((s32)&D_002214D0, 1);
-    func_00157F98();
-    if (D_003D9BE0[0].f4F == 0) {
-        D_003D9BE0[0].f0 = arg0;
-    }
-    saved = func_00505B20();
-    func_00505AD8(4);
-    func_00501498(func_004D36E0());
-    func_00505C90((s32)func_004D36E0());
-    func_00505AD8(saved);
-    if (D_0021FB2C != 0) {
-        D_0021FB2C = 0;
-        func_004E21D8(-1, 0, 0);
-    }
-    if (D_0021DDCC != 0) {
-        func_0048FA80(D_0021DDCC);
-    }
-}
diff --git a/nonmatching/game/func_004D9408.c b/nonmatching/game/func_004D9408.c
deleted file mode 100644
index cd7f00dd3..000000000
--- a/nonmatching/game/func_004D9408.c
+++ /dev/null
@@ -1,61 +0,0 @@
-/* Not matching yet: BYTES 6/236 (tools/try_func.py func_004D9408 --diff). Not part of the build. */
-#include "common.h"
-
-typedef struct {
-    s32 f0;
-    s32 f4;
-} Type4;
-typedef struct {
-    char pad0[8];
-    Type4 *f8;
-    char pad0C[0xC];
-} Type3;
-typedef struct {
-    char pad0[0x34];
-    Type3 *f34;
-    char pad38[0x18];
-    s32 f50;
-    s32 f54;
-} Type1;
-typedef struct {
-    char pad0[8];
-    s32 f8;
-    s32 fC;
-} Type2;
-
-extern s32 func_00505B20(void);
-extern s32 func_00499CA0(void *, s32);
-extern void func_00499CE0(s32);
-extern s32 func_004A1A60(s32 *, s32);
-extern s32 func_00506120(s32, s32);
-extern s32 func_00505238(s32, s32);
-extern u8 D_00321140[];
-extern char D_001CE2F8[];
-extern s32 D_00221B48;
-
-void func_004D9408(void) {
-    Type2 *rec;
-    Type1 *blk;
-    Type3 *ent;
-    Type4 *s1;
-    s32 idx;
-
-    rec = (Type2 *)(D_00321140 + func_00505B20() * 0x114);
-    blk = (Type1 *)((u8 *)rec + 0xA8);
-    if (blk->f50 > 0) {
-        idx = blk->f54;
-        ent = 0;
-        if (idx >= 0) {
-            ent = &blk->f34[idx];
-        }
-        s1 = ent->f8;
-        if (rec->fC != 0) {
-            func_00499CE0(rec->fC);
-            rec->fC = 0;
-        }
-        rec->fC = func_00499CA0(D_001CE2F8 + s1->f4 * 8, -1);
-        func_00506120(func_004A1A60(&D_00221B48, 2), rec->fC);
-        func_00505238(func_004A1A60(&D_00221B48, 6), s1->f0);
-    }
-    rec->f8 &= ~2;
-}
diff --git a/nonmatching/game/func_004F7FD8.c b/nonmatching/game/func_004F7FD8.c
deleted file mode 100644
index 42379877f..000000000
--- a/nonmatching/game/func_004F7FD8.c
+++ /dev/null
@@ -1,77 +0,0 @@
-/* Not matching yet: BYTES 66/508 (tools/try_func.py func_004F7FD8 --diff). Not part of the build. */
-#include "common.h"
-
-typedef struct {
-    u8 pad0[0x50];
-    s32 unk50;
-    u8 pad54[3];
-    u8 unk57;
-    u8 pad58[0xA];
-    s8 unk62;
-} Type1;
-
-extern void func_004F7A48(u64 **arg0, s32 arg1, s32 arg2);
-extern void func_004F7A98(u64 **arg0, s32 arg1, s32 arg2);
-extern s32 D_0021DECC;
-extern s32 D_0021DF0C;
-extern s32 D_0021DF18;
-extern u64 D_0020C6C0[];
-extern s32 D_00221F74;
-
-Type1 *D_002209F8 = 0;
-
-void func_004F7FD8(void) {
-    u64 *p;
-    u64 *base;
-    s32 n;
-    s32 i;
-    s32 v;
-
-    base = D_0020C6C0;
-    p = base;
-    if (D_002209F8->unk57 == 0 && D_002209F8->unk62 == -1) {
-        D_0021DECC = 0;
-        D_00221F74 = D_0021DF0C;
-        return;
-    }
-    *p = 0x1000000000000005;
-    p++;
-    *p = 0xE;
-    p++;
-    *p = 0;
-    p++;
-    *p = 0x3F;
-    p++;
-    *p = 0xA0000000A0;
-    p++;
-    *p = 0x19;
-    p++;
-    *p = 0x100000000;
-    p++;
-    *p = 0x4F;
-    p++;
-    *p = 0x60;
-    p++;
-    *p = 0x15;
-    p++;
-    *p = 5;
-    p++;
-    *p = 9;
-    p++;
-    n = D_002209F8->unk50;
-    if (n >= 5) {
-        n = 4;
-    }
-    D_002209F8->unk50 = n;
-    if (D_002209F8->unk50 == 4) {
-        func_004F7A98(&p, D_0021DF0C, D_0021DF18);
-        v = D_0021DF18;
-    } else {
-        for (i = 0; i < D_002209F8->unk50; i++) {
-            func_004F7A48(&p, D_0021DF0C, D_0021DF18);
-        }
-        v = D_0021DF0C;
-    }
-    D_00221F74 = v;
-    D_0021DECC = (s32)p - (s32)base;
-}
diff --git a/nonmatching/game/func_0054ACE8.c b/nonmatching/game/func_0054ACE8.c
deleted file mode 100644
index 9957347fa..000000000
--- a/nonmatching/game/func_0054ACE8.c
+++ /dev/null
@@ -1,36 +0,0 @@
-/* Not matching yet: BYTES 17/224 (tools/try_func.py func_0054ACE8 --diff). Not part of the build. */
-#include "common.h"
-
-extern s32 func_0054AB98(s32 arg0, s32 *arg1);
-s32 func_0054ADC8(s32 *arg0);
-extern s32 D_00171B4C[];
-extern unsigned int D_00171C08[];
-extern u8 D_1F87F0[];
-
-s32 func_0054ACE8(s32 *arg0) {
-    s32 buf;
-    s32 id;
-    s32 r;
-    s32 ret;
-
-    if (func_0054ADC8(arg0) == 0) {
-        return 0;
-    }
-    ret = 0;
-    if (arg0[0] > D_00171B4C[0]) {
-        return ret;
-    }
-    if ((u32)(arg0[4] + 1) >= 2) {
-        r = func_0054AB98(arg0[4], &buf);
-        if (D_1F87F0[r * 12 + ((buf - 1) % 20) * 0x304 + 9] == 0) {
-            return 0;
-        }
-    }
-    id = arg0[5];
-    if (id == -1 || (D_00171C08[(u32)id >> 5] & (1 << (id & 31)))) {
-        ret = 1;
-    } else {
-        ret = 0;
-    }
-    return ret;
-}
diff --git a/nonmatching/l00_multiplayer_menu/func_L00_00776698.c b/nonmatching/l00_multiplayer_menu/func_L00_00776698.c
deleted file mode 100644
index c79bfe6d9..000000000
--- a/nonmatching/l00_multiplayer_menu/func_L00_00776698.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/* Not matching yet: BYTES 47/76 (tools/try_func.py func_L00_00776698 --diff). Not part of the build. */
-/* cflags: @ee296 -O2 -G0 */
-#include "common.h"
-
-// Reset the selection slots.
-void func_L00_00776698(u8 *p) {
-    s32 i;
-
-    *(s32 *)(p + 0x1E4) = 1;
-    *(u8 *)(p + 0x0) = 0;
-    *(u8 *)(p + 0x14C) = 0;
-    *(u8 *)(p + 0x1C0) = 0;
-    for (i = 0; i < 0x14; i++) {
-        *(s32 *)(p + 0x1E8 + i * 4) = -1;
-        *(s32 *)(p + 0x24C + i * 4) = 0;
-        *(u8 *)(p + 0x238 + i) = 0;
-    }
-}
diff --git a/nonmatching/shared/func_L00_00599710.c b/nonmatching/shared/func_L00_00599710.c
deleted file mode 100644
index de870a21f..000000000
--- a/nonmatching/shared/func_L00_00599710.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Not matching yet: BYTES 78/516 (tools/try_func.py func_L00_00599710 --diff). Not part of the build. */
-typedef struct {
-    u8 pad0[0x74];
-    u16 f74;
-    u8 pad76[0xBC - 0x76];
-    s16 fBC;
-} Type1;
-
-typedef struct {
-    u8 pad0[0x31];
-    u8 f31;
-} Type2;
-
-typedef struct {
-    u8 pad0[0x2EF0];
-    Type2 *f2EF0;
-} Type4;
-
-typedef struct {
-    u8 pad0[0x70];
-    s32 f70;
-    u8 pad74[0x84 - 0x74];
-    s16 f84;
-    u8 pad86[0x1F0 - 0x86];
-    Type1 *f1F0[1];
-} Type3;
-
-extern void func_L00_00596A28(s32, s32, s32, s32);
-extern void func_L00_00598118(s32);
-extern Type3 D_0023BE00[];
-extern Type4 *D_00343E78[];
-
-// Set per-entry effects by type, then clear a flag in ten slots
-void func_L00_00599710(void) {
-    Type3 *base = D_0023BE00;
-    Type4 **q = D_00343E78;
-    s32 i;
-    Type1 *p;
-
-    for (i = 0; i < base->f84; i++) {
-        p = base->f1F0[i];
-        if (p == NULL) {
-            continue;
-        }
-        if (p->fBC == 0x216A || p->fBC == 0x2691
-            || (p->fBC == 0x2429 && *(s32 *)0x21DE10 == 0x2574)
-            || p->fBC == 0x20FD || p->fBC == 0x2703 || p->fBC == 0x2505) {
-            func_L00_00596A28(i, 0x96, 0, 0);
-        }
-        if (p->fBC == 0x216A || p->fBC == 0x2691) {
-            base->f1F0[i]->f74 |= 0x1000;
-        }
-        if (p->fBC == 0xA) {
-            if (base->f70 == 2) {
-                base->f1F0[i]->f74 |= 0x1000;
-            } else {
-                base->f1F0[i]->f74 |= 0x1002;
-            }
-            func_L00_00596A28(i, 0x6E, 0x80306629, 0x8058B856);
-        }
-        if (p->fBC == 0x243D) {
-            func_L00_00596A28(i, 0x168, 0xC0808080, 0x80505050);
-        }
-        if (p->fBC == 0x247F || p->fBC == 0x24D9 || p->fBC == 0x24D5) {
-            func_L00_00596A28(i, 0x5A, 0xFFC0C0C0, 0xB0505050);
-        }
-    }
-    func_L00_00598118(0);
-    for (i = 0; i < 10; i++) {
-        if (q[i] != NULL) {
-            q[i]->f2EF0->f31 = 0;
-        }
-    }
-}
diff --git a/nonmatching/shared/func_L01_0063B1B8.c b/nonmatching/shared/func_L01_0063B1B8.c
deleted file mode 100644
index 3b9f8ea22..000000000
--- a/nonmatching/shared/func_L01_0063B1B8.c
+++ /dev/null
@@ -1,13 +0,0 @@
-/* Not matching yet: BYTES 32/44 (tools/try_func.py func_L01_0063B1B8 --diff). Not part of the build. */
-#include "common.h"
-
-// Release index `i` from the table and drop the reference count.
-void func_L01_0063B1B8(u8 *p, s32 i) {
-    u8 *e = p + i * 4;
-
-    *(s32 *)(e + 0x0) = 0;
-    *(s32 *)(e + 0x100) = 0;
-    if (--*(s32 *)(p + 0x220) == 0) {
-        *(s32 *)(p + 0x224) = 0;
-    }
-}
diff --git a/src/pal/core/0012AA70.c b/src/core/0012AA70.c
similarity index 100%
rename from src/pal/core/0012AA70.c
rename to src/core/0012AA70.c
diff --git a/src/pal/core/0012CA90.c b/src/core/0012CA90.c
similarity index 72%
rename from src/pal/core/0012CA90.c
rename to src/core/0012CA90.c
index 653605f60..4a2ba5c2b 100644
--- a/src/pal/core/0012CA90.c
+++ b/src/core/0012CA90.c
@@ -1,8 +1,8 @@
 /* cflags: @ee29 -O2 -G0 */
 #include "common.h"
 
-extern s32 D_001A9580[];
-extern u8 D_001A9780[];
+extern s32 D_001A9500[];
+extern u8 D_001A9700[];
 extern s32 func_0012C4B8(void);
 extern s32 func_0012C5B8(void);
 extern s32 func_0012A718(void *client, s32 command, u32 mode,
@@ -18,10 +18,10 @@ s32 func_0012CA90(s32 descriptor)
     if (func_0012C5B8()) {
         return (s32)0xFFFEFFFCu;
     }
-    D_001A9580[0] = descriptor;
-    if (func_0012A718(D_001A9780, 8, 0, D_001A9580, 4,
-                      D_001A9580, 4, 0, 0) < 0) {
+    D_001A9500[0] = descriptor;
+    if (func_0012A718(D_001A9700, 8, 0, D_001A9500, 4,
+                      D_001A9500, 4, 0, 0) < 0) {
         return (s32)0xFFFEFFFFu;
     }
-    return D_001A9580[0];
+    return D_001A9500[0];
 }
diff --git a/src/pal/core/001373B0.c b/src/core/001373B0.c
similarity index 65%
rename from src/pal/core/001373B0.c
rename to src/core/001373B0.c
index 8111e9ba5..7fbdbb093 100644
--- a/src/pal/core/001373B0.c
+++ b/src/core/001373B0.c
@@ -1,8 +1,8 @@
 /* cflags: @ee29 -O2 -G0 */
 #include "common.h"
-extern u8 D_00167210[];
-extern s32 D_001660C0[];
-extern s32 D_00166068;
+extern u8 D_00167190[];
+extern s32 D_00166040[];
+extern s32 D_00165FE8;
 extern s32 func_00137258(s32 command);
 extern s32 func_00126BC0(s32 semaphore);
 extern s32 func_0012A718(void *client, s32 command, u32 mode,
@@ -13,11 +13,11 @@ s32 func_001373B0(void)
     s32 result;
     if (!func_00137258(2))
         return 0;
-    if (func_0012A718(D_00167210, 14, 0, 0, 0, D_001660C0, 4, 0, 0) < 0) {
-        func_00126BC0(D_00166068);
+    if (func_0012A718(D_00167190, 14, 0, 0, 0, D_00166040, 4, 0, 0) < 0) {
+        func_00126BC0(D_00165FE8);
         return 0;
     }
-    result = *(s32 *)((u32)D_001660C0 | 0x20000000u);
-    func_00126BC0(D_00166068);
+    result = *(s32 *)((u32)D_00166040 | 0x20000000u);
+    func_00126BC0(D_00165FE8);
     return result;
 }
diff --git a/src/pal/core/00137FB0.c b/src/core/00137FB0.c
similarity index 65%
rename from src/pal/core/00137FB0.c
rename to src/core/00137FB0.c
index b7e8d2b0e..0bb53bc75 100644
--- a/src/pal/core/00137FB0.c
+++ b/src/core/00137FB0.c
@@ -1,8 +1,8 @@
 /* cflags: @ee29 -O2 -G0 */
 #include "common.h"
-extern u8 D_00167BC0[];
-extern s32 D_00167240[];
-extern s32 D_0016606C;
+extern u8 D_00167B40[];
+extern s32 D_001671C0[];
+extern s32 D_00165FEC;
 extern s32 func_00137558(s32 command);
 extern s32 func_00126BC0(s32 semaphore);
 extern s32 func_0012A718(void *client, s32 command, u32 mode,
@@ -13,11 +13,11 @@ s32 func_00137FB0(void)
     s32 result;
     if (!func_00137558(3))
         return -1;
-    if (func_0012A718(D_00167BC0, 4, 0, 0, 0, D_00167240, 4, 0, 0) < 0) {
-        func_00126BC0(D_0016606C);
+    if (func_0012A718(D_00167B40, 4, 0, 0, 0, D_001671C0, 4, 0, 0) < 0) {
+        func_00126BC0(D_00165FEC);
         return -1;
     }
-    result = *(s32 *)((u32)D_00167240 | 0x20000000u);
-    func_00126BC0(D_0016606C);
+    result = *(s32 *)((u32)D_001671C0 | 0x20000000u);
+    func_00126BC0(D_00165FEC);
     return result;
 }
diff --git a/src/pal/core/00138100.c b/src/core/00138100.c
similarity index 61%
rename from src/pal/core/00138100.c
rename to src/core/00138100.c
index 4e4f02e8e..819fd863f 100644
--- a/src/pal/core/00138100.c
+++ b/src/core/00138100.c
@@ -1,8 +1,8 @@
 /* cflags: @ee29 -O2 -G0 */
 #include "common.h"
-extern u8 D_00167BC0[];
-extern s32 D_00167240[];
-extern s32 D_0016606C;
+extern u8 D_00167B40[];
+extern s32 D_001671C0[];
+extern s32 D_00165FEC;
 extern s32 func_00137558(s32 command);
 extern s32 func_00126BC0(s32 semaphore);
 extern s32 func_0012A718(void *client, s32 command, u32 mode,
@@ -13,12 +13,12 @@ s32 func_00138100(s32 *output)
     s32 result;
     if (!func_00137558(33))
         return 0;
-    if (func_0012A718(D_00167BC0, 33, 0, 0, 0, D_00167240, 8, 0, 0) < 0) {
-        func_00126BC0(D_0016606C);
+    if (func_0012A718(D_00167B40, 33, 0, 0, 0, D_001671C0, 8, 0, 0) < 0) {
+        func_00126BC0(D_00165FEC);
         return 0;
     }
-    *output = *(s32 *)(((u32)D_00167240 + 4u) | 0x20000000u);
-    result = *(s32 *)((u32)D_00167240 | 0x20000000u);
-    func_00126BC0(D_0016606C);
+    *output = *(s32 *)(((u32)D_001671C0 + 4u) | 0x20000000u);
+    result = *(s32 *)((u32)D_001671C0 | 0x20000000u);
+    func_00126BC0(D_00165FEC);
     return result;
 }
diff --git a/src/pal/core/00139DA0.c b/src/core/00139DA0.c
similarity index 86%
rename from src/pal/core/00139DA0.c
rename to src/core/00139DA0.c
index 04f521463..7794314a9 100644
--- a/src/pal/core/00139DA0.c
+++ b/src/core/00139DA0.c
@@ -2,7 +2,7 @@
 #include "common.h"
 extern u32 func_00139A58(u32);
 extern void func_001399E0(void *);
-/* Programs channel registers after waiting for the prior transfer. */
+
 void func_00139DA0(u8 *object, u32 address)
 {
     u32 value = func_00139A58(address);
diff --git a/src/core/0013A0F0.c b/src/core/0013A0F0.c
new file mode 100644
index 000000000..2fccc65ae
--- /dev/null
+++ b/src/core/0013A0F0.c
@@ -0,0 +1,17 @@
+/* cflags: @ee29 -O2 -G0 */
+#include "common.h"
+
+s32 func_00126BB0(s32);
+s32 func_0013A7A0(s32, s32, s32);
+extern s32 D_00167BFC[];
+extern s32 D_00167C00[];
+
+s32 func_0013A0F0(void) {
+    if (D_00167BFC[0] >= 0) {
+        func_0013A7A0(0, 0, 0);
+        func_00126BB0(D_00167BFC[0]);
+        D_00167BFC[0] = -1;
+        func_00126BB0(D_00167C00[0]);
+    }
+    return 1;
+}
diff --git a/src/pal/core/0013B460.c b/src/core/0013B460.c
similarity index 62%
rename from src/pal/core/0013B460.c
rename to src/core/0013B460.c
index 92e3dea48..ac329b528 100644
--- a/src/pal/core/0013B460.c
+++ b/src/core/0013B460.c
@@ -1,10 +1,10 @@
 /* cflags: @ee29 -O2 -G0 */
 #include "common.h"
 
-extern u8 D_001AF040[];
-extern s32 D_001AF280[];
-extern s32 D_00167C98[];
-extern s32 D_00167CA4[];
+extern u8 D_001AEFC0[];
+extern s32 D_001AF200[];
+extern s32 D_00167C18[];
+extern s32 D_00167C24[];
 extern s32 func_0013C2E8(s32 enabled);
 extern void func_00129990(s32 command);
 extern s32 func_0012A718(void *client, s32 command, u32 mode,
@@ -16,20 +16,20 @@ s32 func_0013B460(void)
 {
     s32 result;
 
-    if (D_00167C98[0] == 0) {
+    if (D_00167C18[0] == 0) {
         return 1;
     }
     func_0013C2E8(0);
-    D_001AF280[0] = 15;
-    if (func_0012A718(D_001AF040, 1, 0, D_001AF280, 0x80,
-                      D_001AF280, 0x80, 0, 0) < 0) {
+    D_001AF200[0] = 15;
+    if (func_0012A718(D_001AEFC0, 1, 0, D_001AF200, 0x80,
+                      D_001AF200, 0x80, 0, 0) < 0) {
         return 0;
     }
     func_00129990((s32)0x80000019u);
-    result = D_001AF280[3];
+    result = D_001AF200[3];
     if (result == 1) {
-        D_00167C98[0] = 0;
+        D_00167C18[0] = 0;
     }
-    D_00167CA4[0] = 0;
+    D_00167C24[0] = 0;
     return result;
 }
diff --git a/src/core/001464C0.c b/src/core/001464C0.c
new file mode 100644
index 000000000..a7136e45b
--- /dev/null
+++ b/src/core/001464C0.c
@@ -0,0 +1,9 @@
+/* cflags: @ee29 -O2 -G0 */
+#include "common.h"
+
+s32 func_001294F0(void *, s32);
+extern s32 D_00195770[];
+
+void func_001464C0(s32 arg0) {
+    func_001294F0(D_00195770, arg0);
+}
diff --git a/src/pal/core/0014C168.c b/src/core/0014C168.c
similarity index 79%
rename from src/pal/core/0014C168.c
rename to src/core/0014C168.c
index fd2e68b8a..c62e3d893 100644
--- a/src/pal/core/0014C168.c
+++ b/src/core/0014C168.c
@@ -1,21 +1,21 @@
 /* cflags: -fno-opt-stack */
 #include "common.h"
-extern const f32 D_001A0218[];
+extern const f32 D_001A0198[];
 extern f32 func_001484E8(const s32 *steps, s32 unused, const f32 *samples,
                          f32 frequency, s32 length, f32 gain);
 f32 func_0014C168(s32 index, const s32 *steps, s32 unused, const f32 *samples, s32 length, f32 gain, f32 *score)
 {
     f32 candidates[2];
-    f32 best = *(const f32 *)((u32)D_001A0218 + ((u32)index << 2));
+    f32 best = *(const f32 *)((u32)D_001A0198 + ((u32)index << 2));
     s32 count = 0;
     s32 i;
     if (index > 0) {
-        f32 previous = *(const f32 *)((u32)D_001A0218 + (((u32)index - 1u) << 2));
+        f32 previous = *(const f32 *)((u32)D_001A0198 + (((u32)index - 1u) << 2));
         candidates[count++] = (best + previous) * 0.5f;
     }
     index = (s32)((u32)index + 1u);
     if (index < 74) {
-        f32 next = *(const f32 *)((u32)D_001A0218 + ((u32)index << 2));
+        f32 next = *(const f32 *)((u32)D_001A0198 + ((u32)index << 2));
         candidates[count++] = (best + next) * 0.5f;
     }
     for (i = 0; i < count; i++) {
diff --git a/src/pal/core/0014CCA0.c b/src/core/0014CCA0.c
similarity index 100%
rename from src/pal/core/0014CCA0.c
rename to src/core/0014CCA0.c
diff --git a/src/pal/core/001501B0.c b/src/core/001501B0.c
similarity index 60%
rename from src/pal/core/001501B0.c
rename to src/core/001501B0.c
index 700a414cd..0bf103221 100644
--- a/src/pal/core/001501B0.c
+++ b/src/core/001501B0.c
@@ -1,18 +1,18 @@
 /* cflags: -fno-opt-stack */
 #include "common.h"
 
-extern const f32 D_001A3A20[];
-extern const f32 D_001A3A08[];
+extern const f32 D_001A39A0[];
+extern const f32 D_001A3988[];
 extern f32 func_00147DE0(f32 value);
 
 f32 func_001501B0(f32 value, f32 scale)
 {
     s32 band;
     for (band = 0; band < 5; ++band) {
-        if (D_001A3A20[band] < value) {
+        if (D_001A39A0[band] < value) {
             break;
         }
     }
-    return (D_001A3A08[band] + func_00147DE0(scale) * 0.5f) +
+    return (D_001A3988[band] + func_00147DE0(scale) * 0.5f) +
            -5.045318603515625f;
 }
diff --git a/src/core/00159258.c b/src/core/00159258.c
new file mode 100644
index 000000000..981c244b5
--- /dev/null
+++ b/src/core/00159258.c
@@ -0,0 +1,20 @@
+#include "common.h"
+
+extern void func_00158C60(s32 a0, s32 a1, void *a2, s32 a3, s64 t0);
+
+void func_00159258(s32 arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7, s32 arg8, s32 arg9, s32 arg10, s64 arg11) {
+    s32 buf[8];
+    s32 p02;
+    s32 p13;
+    p13 = ((u32)arg5 << 16) | (arg3 & 0xFFFF);
+    p02 = ((u32)arg4 << 16) | (arg2 & 0xFFFF);
+    buf[0] = arg0;
+    buf[1] = arg1;
+    buf[2] = p02;
+    buf[3] = p13;
+    buf[4] = arg6;
+    buf[5] = arg7;
+    buf[6] = arg8;
+    buf[7] = arg9;
+    func_00158C60(0x2C, 0x20, buf, arg10, arg11);
+}
diff --git a/src/core/00160FD8.c b/src/core/00160FD8.c
new file mode 100644
index 000000000..b7fbd6631
--- /dev/null
+++ b/src/core/00160FD8.c
@@ -0,0 +1,57 @@
+/* cflags: -mno-split-addresses */
+#include "common.h"
+
+extern s32 D_0021DDB8[];
+
+void func_00160FD8(void *object) {
+    s32 remaining;
+    s32 now;
+    void *node;
+    void *current;
+    void *next;
+
+    node = (*(void **)((s8 *)(object) + (0xAAC)));
+    (*(s8 *)((s8 *)(object) + (0xA99))) = 0;
+    if (node != NULL) {
+        (*(s8 *)((s8 *)(node) + (0xA0))) = 0;
+        remaining = (s32)((u32)(*(s32 *)((s8 *)(object) + (0xAA0))) - 1U);
+        (*(void **)((s8 *)(object) + (0xAAC))) = (void *) (*(void **)((s8 *)((*(void **)((s8 *)(object) + (0xAAC)))) + (0x98)));
+        (*(s32 *)((s8 *)(object) + (0xAA0))) = remaining;
+        if (remaining >= 4) {
+            now = D_0021DDB8[0];
+            if (((s32)((u32)now - (u32)(*(s32 *)((s8 *)(object) + (0xAA4))))) >= 0x385) {
+                (*(s32 *)((s8 *)(object) + (0xAA4))) = (s32)((u32)now - 0x258U);
+                if ((*(s8 *)((s8 *)(object) + (0xAA9))) <= 0) {
+                    (*(s8 *)((s8 *)(object) + (0xAA9))) = 1;
+                }
+            }
+        }
+        next = (*(void **)((s8 *)(object) + (0xAAC)));
+        if (next != NULL) {
+            if ((*(u8 *)((s8 *)(object) + (0xAA8))) != 0) {
+                (*(s8 *)((s8 *)(next) + (0xA0))) = 0;
+                (*(void **)((s8 *)(object) + (0xAAC))) = (void *) (*(void **)((s8 *)((*(void **)((s8 *)(object) + (0xAAC)))) + (0x98)));
+                (*(s32 *)((s8 *)(object) + (0xAA0))) = (s32) ((s32)((u32)(*(s32 *)((s8 *)(object) + (0xAA0))) - 1U));
+                goto block_8;
+            }
+        } else {
+block_8:
+            if ((*(u8 *)((s8 *)(object) + (0xAA8))) != 0) {
+                if ((*(s32 *)((s8 *)(object) + (0xAA0))) < ((s32) ((f32) (*(s8 *)((s8 *)(object) + (0xAA9))) * 0.25f) + 3)) {
+                    (*(u8 *)((s8 *)(object) + (0xAA8))) = 0U;
+                }
+            }
+        }
+        if (((s32) ((f32) (*(s8 *)((s8 *)(object) + (0xAA9))) * 0.25f) + 4) < (*(s32 *)((s8 *)(object) + (0xAA0)))) {
+            (*(u8 *)((s8 *)(object) + (0xAA8))) = 1U;
+        }
+        current = (*(void **)((s8 *)(object) + (0xAAC)));
+        if (current != NULL) {
+            (*(s32 *)((s8 *)(current) + (0x9C))) = 0;
+            (*(s8 *)((s8 *)(object) + (0xA98))) = 0;
+            (*(s32 *)((s8 *)(object) + (0xA9C))) = (s32) (*(u8 *)((s8 *)((*(void **)((s8 *)(object) + (0xAAC)))) + (0x16)));
+        } else {
+            (*(s32 *)((s8 *)(object) + (0xAB0))) = 0;
+        }
+    }
+}
diff --git a/src/game/0041DA98.c b/src/game/0041DA98.c
new file mode 100644
index 000000000..868a18680
--- /dev/null
+++ b/src/game/0041DA98.c
@@ -0,0 +1,78 @@
+#include "common.h"
+
+typedef struct Hero Hero;
+typedef struct Entity Entity;
+typedef struct Vars Vars;
+typedef struct HeroVtable {
+    u8 unknown0[0x4C];
+    s32 (*identifier)(Hero *hero);
+} HeroVtable;
+struct Hero {
+    u8 unknown0[0x14];
+    HeroVtable *vtable;
+    u8 unknown18[0x25B4];
+    s32 state;
+    u8 unknown25D0[0x9D];
+    u8 active;
+};
+struct Entity {
+    u8 unknown0[0x20];
+    u8 state;
+    u8 unknown21[2];
+    u8 mode;
+    u8 unknown24[0x88];
+    void *vars;
+    u8 unknownB0[0xC];
+    s16 classId;
+};
+struct Vars {
+    Entity *target;
+    u8 unknown4[8];
+    Hero *hero;
+    u8 unknown10[0x10];
+    Entity *effect;
+    u8 unknown24[0xA];
+    u8 active;
+};
+
+extern s32 D_0021DD9C;
+extern void func_0041D860(Entity *entity);
+extern void func_0041D948(Entity *entity);
+extern Hero *func_00510C30(Hero *hero);
+extern void func_004E8DD0(void *first, void *second, s32 flags, s32 reserved, Hero *hero, f32 scale);
+
+void func_0041DA98(Entity *entity)
+{
+    Vars *vars;
+    Hero *hero;
+
+    if (!entity || entity->state == 0xFE || entity->state == 0xFD) {
+        return;
+    }
+    vars = entity->vars;
+    hero = vars->hero;
+    if (entity->mode >= 0x40) {
+        func_0041D860(entity);
+    }
+    if (!vars->target || vars->target->state == 0xFE ||
+        vars->target->state == 0xFD || vars->target->classId != 0x1099) {
+        return;
+    }
+    if (entity->mode >= 0x40) {
+        func_0041D948(entity);
+    }
+    if (!hero || !hero->active) {
+        return;
+    }
+    if (hero->vtable->identifier(hero) != D_0021DD9C || entity->state != 4 ||
+        vars->hero->state == 0xE || !vars->effect || !hero->active || !vars->active) {
+        return;
+    }
+    {
+        u32 effect = (u32)vars->effect->vars;
+        void *first = (void *)(effect + 0xF0);
+        void *second = (void *)(effect + 0x100);
+        Hero *activeHero = func_00510C30(hero);
+        func_004E8DD0(first, second, 0, 1, activeHero, 1.0f);
+    }
+}
diff --git a/src/game/0041E280.c b/src/game/0041E280.c
new file mode 100644
index 000000000..c45c31e72
--- /dev/null
+++ b/src/game/0041E280.c
@@ -0,0 +1,32 @@
+#include "common.h"
+
+extern void func_00547FF8(s32, s32, s32);
+extern void func_00415F40(s32, u8 *, s32);
+extern u8 *func_00548D28(s32, s32);
+extern s32 func_0054A788(s32, s32, s32);
+extern void func_00473A88(u8 *, s32, s32);
+
+void func_0041E280(u8 *moby) {
+    u8 *vars = *(u8 **)(moby + 0xAC);
+    u8 *v;
+    f32 speed;
+    s32 n;
+    s32 id;
+
+    if (*(u8 **)(vars + 0xC) != NULL) {
+        id = *(s32 *)(vars + 0);
+        func_00547FF8(*(s32 *)(*(u8 **)(vars + 0xC) + 0x26E4), 6, 1);
+        func_00415F40(id, *(u8 **)(vars + 0xC), 1);
+        v = *(u8 **)(moby + 0xAC);
+        speed = *(f32 *)(func_00548D28(6, 0) + 0x4C);
+        n = func_0054A788(*(s32 *)(*(u8 **)(v + 0xC) + 0x26E4), 6, 1);
+        if (n != 0) {
+            speed *= 1.0f - n * 0.05f;
+        }
+        speed *= 2.0f;
+        *(s16 *)(v + 6) = (*(s16 *)(v + 4) = speed * 60.0f) * 0.85f;
+        *(f32 *)(*(u8 **)(v + 0xC) + 0x3EC) = speed;
+        *(s32 *)(vars + 0) = 0;
+        func_00473A88(moby, 6, -1);
+    }
+}
diff --git a/src/game/004230F8.c b/src/game/004230F8.c
new file mode 100644
index 000000000..9fa857554
--- /dev/null
+++ b/src/game/004230F8.c
@@ -0,0 +1,43 @@
+#include "common.h"
+
+extern s32 D_0021DE10;
+
+void func_004230F8(const u32 *kind, u32 *first, u32 *second, s32 *flag)
+{
+    switch (*kind) {
+    case 0:
+        *first = 0x00325C66;
+        *second = 0x004C6C74;
+        break;
+    case 1:
+        *first = 0x00325C66;
+        *second = 0x004C6C74;
+        *flag = 0;
+        break;
+    case 2:
+        *first = 0x00325C66;
+        *second = 0x004C6C74;
+        *flag = 1;
+        break;
+    case 3:
+        if (D_0021DE10 == 0x29 || D_0021DE10 == 0x33 || D_0021DE10 == 0x30) {
+            *first = 0x00F0EBEE;
+            *second = 0x00F0EBEE;
+        } else {
+            *first = 0x005786AE;
+            *second = 0x002E475C;
+        }
+        *flag = 0;
+        break;
+    case 4:
+        if (D_0021DE10 == 0x29 || D_0021DE10 == 0x33 || D_0021DE10 == 0x30) {
+            *first = 0x00312B2A;
+            *second = 0x00312B2A;
+        } else {
+            *first = 0x0015212B;
+            *second = 0x00192834;
+        }
+        *flag = 0;
+        break;
+    }
+}
diff --git a/src/game/00429BE8.c b/src/game/00429BE8.c
new file mode 100644
index 000000000..664faddaf
--- /dev/null
+++ b/src/game/00429BE8.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+typedef struct Row48 {
+    u8 unknown0[0x1C];
+    s32 active;
+    u8 unknown20[0x10];
+} Row48;
+
+typedef struct Row80 {
+    u8 unknown0[0x44];
+    s32 active;
+    u8 unknown48[8];
+} Row80;
+
+extern Row48 D_00224ED0[];
+extern Row80 D_00225110[];
+extern u8 *func_0046B930(s32 classId, s32 flags);
+extern void func_00473A88(void *object, s32 state, s32 animation);
+extern s32 func_00461130(const void *position, f32 x, f32 y, f32 z, f32 w, f32 size);
+
+void func_00429BE8(u8 *entity, void *data)
+{
+    u8 *object = func_0046B930(0x24EE, 0x80);
+    if (object && entity && data) {
+        u8 *state;
+        s32 i;
+        object[0x30] = 0xFF;
+        *(u16 *)(object + 0x32) = 0xFF;
+        state = *(u8 **)(object + 0xAC);
+        func_00473A88(object, 0, -1);
+        for (i = 11; i >= 0; i--)
+            D_00224ED0[i].active = 0;
+        for (i = 127; i >= 0; i--)
+            D_00225110[i].active = 0;
+        *(s32 *)(state + 0x10) = func_00461130(object + 0x10, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+        *(u8 **)(state + 0x18) = entity;
+        *(s32 *)(state + 0x14) = *(s16 *)(entity + 0xBC);
+        *(void **)(state + 0x1C) = data;
+    }
+}
diff --git a/src/game/0042B700.c b/src/game/0042B700.c
new file mode 100644
index 000000000..31a5521c4
--- /dev/null
+++ b/src/game/0042B700.c
@@ -0,0 +1,29 @@
+#include "common.h"
+
+typedef struct {
+    u8 *object;
+    u32 color;
+    s32 reserved;
+    f32 fraction;
+    u8 tail[16];
+} Entry;
+extern Entry D_00227920[];
+extern u8 **func_004765B0(void *);
+extern u32 func_00453C68(u32, u32, f32);
+extern void func_004700B0(void *, u32, u32, u32);
+void func_0042B700(s32 index, u32 color)
+{
+    s32 alpha;
+    u8 **child;
+    s32 mixed, red, green, blue;
+    alpha = (s32)(D_00227920[index].fraction * 96.0f);
+    D_00227920[index].object[35] = alpha;
+    child = func_004765B0(D_00227920[index].object);
+    if (child != 0 && *child != 0)
+        (*child)[35] = alpha;
+    mixed = func_00453C68(color, D_00227920[index].color, D_00227920[index].fraction);
+    blue = (mixed >> 16) & 0xFF;
+    green = (mixed >> 8) & 0xFF;
+    red = mixed & 0xFF;
+    func_004700B0(D_00227920[index].object, red, green, blue);
+}
diff --git a/src/game/00430D08.c b/src/game/00430D08.c
new file mode 100644
index 000000000..9faf26fcd
--- /dev/null
+++ b/src/game/00430D08.c
@@ -0,0 +1,32 @@
+#include "common.h"
+
+extern s32 D_0021DDB4;
+
+s32 func_00505B20(void);
+s32 func_00505AD8(s32 arg0);
+s32 func_00506BA8(s32 arg0);
+s32 func_00505410(s32 arg0, f32 arg1);
+
+void func_00430D08(s32 arg0, f32 arg1)
+{
+    s32 index;
+    s32 i;
+
+    index = func_00505B20();
+    func_00505AD8(arg0);
+    if (func_00506BA8(0x1D0000) == 0) {
+        func_00505AD8(index);
+        return;
+    }
+    if (D_0021DDB4 == 0) {
+        for (i = 0; i < 0x14; i++) {
+            if (arg1 <= 0.0f) {
+                continue;
+            }
+            if (arg1 < 1.0f) {
+                func_00505410(0x1D0001 + i, arg1);
+            }
+        }
+    }
+    func_00505AD8(index);
+}
diff --git a/src/game/00430E80.c b/src/game/00430E80.c
new file mode 100644
index 000000000..b924fe368
--- /dev/null
+++ b/src/game/00430E80.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Allocator *func_005011A8(Manager *, s32);
+extern void func_00504228(s32);
+extern s32 func_00504230(void);
+extern s32 func_004FF910(void *, u32);
+extern void *func_0015DB80(u32, void *);
+extern Object *func_0050DAE0(void *);
+extern s32 func_005005A8(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00222038;
+    if (manager->table) {
+        return manager;
+    }
+    return func_005010E0();
+}
+
+s32 func_00430E80(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_00504228(0x5C);
+    size = func_00504230();
+    if (entry != NULL && func_004FF910(entry, key) == 0) {
+        allocator = func_005011A8(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_0050DAE0(func_0015DB80(0x5C, block));
+            result = func_005005A8(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_005011A8(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/game/004331B0.c b/src/game/004331B0.c
new file mode 100644
index 000000000..430abe63b
--- /dev/null
+++ b/src/game/004331B0.c
@@ -0,0 +1,39 @@
+#include "common.h"
+
+typedef struct HeroVtable {
+    u8 unknown0[0x4C];
+    s32 (*identifier)(void *);
+} HeroVtable;
+
+extern s32 D_0021EDD4;
+extern u8 *func_00510BE8(s32 context);
+extern u8 *func_00510C18(s32 context);
+extern s32 func_0054A788(void *inventory, s32 slot, s32 kind);
+extern f32 func_004725D8(f32 first, f32 last);
+extern s32 func_005481A8(void *inventory, s32 slot, s32 amount);
+extern void func_00549100(void *inventory, s32 slot, void *object,
+                          void *data, s32 identifier, s32 notify);
+
+void func_004331B0(void *object, s32 amount)
+{
+    f32 value = (f32)amount;
+    u8 *data = *(u8 **)((u8 *)object + 0xAC);
+    u8 *hero = func_00510BE8(0);
+    s32 result;
+    if (hero) {
+        result = func_0054A788(*(void **)(hero + 0x26E4), 8, 6);
+        value += (f32)result * 0.5f * value;
+    }
+    value += func_004725D8(0.0f, 1.0f);
+    hero = func_00510C18(data[0x16]);
+    if (D_0021EDD4 != 1) {
+        result = func_005481A8(*(void **)(hero + 0x26E4), 8, (s32)value);
+        if (result) {
+            void *entity = *(void **)(hero + 0x22F0);
+            HeroVtable *vtable = *(HeroVtable **)(hero + 0x14);
+            s32 id = vtable->identifier(hero);
+            func_00549100(*(void **)(hero + 0x26E4), 8, entity,
+                          hero + 0x2ED2, id, 1);
+        }
+    }
+}
diff --git a/src/game/004332B0.c b/src/game/004332B0.c
new file mode 100644
index 000000000..96e41279c
--- /dev/null
+++ b/src/game/004332B0.c
@@ -0,0 +1,14 @@
+#include "common.h"
+
+s32 func_004332B0(s32 arg0) {
+    f32 var_f2;
+
+    var_f2 = 10.0f;
+    if (arg0 < 0xA) {
+        var_f2 = (f32) ((s32)((u32)arg0 * 2U)) + var_f2;
+    } else {
+        var_f2 = 28.0f;
+        var_f2 = (f32) ((s32)((u32)arg0 - 9U)) * 0.3f + var_f2;
+    }
+    return (s32) var_f2;
+}
diff --git a/src/game/004363D0.c b/src/game/004363D0.c
new file mode 100644
index 000000000..ffdeba590
--- /dev/null
+++ b/src/game/004363D0.c
@@ -0,0 +1,22 @@
+#include "common.h"
+
+void func_00452E98(const f32 *position,s32 texture,u32 color,s32 style,f32 size,f32 depth,f32 rotation);
+f32 func_00453B10(f32 angle,f32 change);
+f32 func_00472690(void);
+
+void func_004363D0(void *arg0) {
+    f32 *temp_s0;
+    f32 temp_f0;
+    void *temp_s1;
+
+    temp_s1 = (*(void **)((s8 *)(arg0) + (0xAC)));
+    temp_s0 = arg0;
+    temp_f0 = func_00453B10((*(f32 *)((s8 *)(temp_s1) + (0x10))), 0.017453292f);
+    (*(f32 *)((s8 *)(temp_s1) + (0x10))) = temp_f0;
+    func_00452E98(temp_s0 + 4, 0x39, 0x40505050U, 1, 0.5f, 0.08f, func_00453B10(temp_f0 * 2.5f, 0.0f));
+    func_00452E98(temp_s0 + 4, 0x2A, 0x207F2040U, 1, 0.5f, 0.08f, func_00453B10(-(*(f32 *)((s8 *)(temp_s1) + (0x10))) * 1.5f, 0.0f));
+    func_00452E98(temp_s0 + 4, 0x2C, 0x207F2040U, 1, 0.5f, 0.08f, func_00453B10((*(f32 *)((s8 *)(temp_s1) + (0x10))), 0.0f));
+    func_00452E98(temp_s0 + 4, 0x31, 0x20FF7F00U, 1, 0.36f, 0.08f, (*(f32 *)((s8 *)(temp_s1) + (0x10))) * 0.5f);
+    func_00452E98(temp_s0 + 4, 0x31, 0x20FF7FU, 1, 0.36f, 0.08f, (*(f32 *)((s8 *)(temp_s1) + (0x10))) * -0.5f);
+    func_00452E98(temp_s0 + 4, 0x2F, 0x507F7F7FU, 1, 0.11f, 0.08f, func_00472690());
+}
diff --git a/src/game/0043D160.c b/src/game/0043D160.c
new file mode 100644
index 000000000..5998eabdc
--- /dev/null
+++ b/src/game/0043D160.c
@@ -0,0 +1,26 @@
+#include "common.h"
+
+typedef struct {
+    u8 prefix[0xC8];
+    f32 fC8, fCC;
+    s32 fD0;
+    u8 tail[0x39C];
+} State;
+extern State D_00229CE0[];
+extern f32 D_002211D0;
+extern f32 func_004757A0(f32 *, f32, f32);
+extern s32 func_004534D0(s32 *);
+void func_0043D160(s32 index)
+{
+    State *state = (State *)((u32)D_00229CE0 + (u32)index * 0x470);
+    if (state->fC8 != 0.0f) {
+        f32 *value = (f32 *)((u32)index * 4 + (u32)&D_002211D0);
+        func_004757A0(value, state->fCC, state->fC8);
+        if (*value == state->fCC) {
+            if (func_004534D0(&state->fD0) == 1)
+                state->fCC = 0.0f;
+        }
+        if (state->fCC <= 0.0f && *(f32 *)((u32)index * 4 + (u32)&D_002211D0) <= 0.0f)
+            state->fC8 = 0.0f;
+    }
+}
diff --git a/src/game/0043D250.c b/src/game/0043D250.c
new file mode 100644
index 000000000..a9683c9db
--- /dev/null
+++ b/src/game/0043D250.c
@@ -0,0 +1,32 @@
+#include "common.h"
+
+typedef struct {
+    u8 p0[0xD4];
+    f32 fD4, fD8;
+    union {
+        f32 value;
+        s32 bits;
+    } fDC;
+    s32 fE0;
+    u8 tail[0x38C];
+} State;
+extern State D_00229CE0[];
+extern f32 D_002211E0;
+extern f32 func_004757A0(f32 *, f32, f32);
+extern s32 func_004534D0(s32 *);
+void func_0043D250(s32 index)
+{
+    State *state = (State *)((u32)D_00229CE0 + (u32)index * 0x470);
+    if (state->fD4 != 0.0f) {
+        if (state->fDC.value != 0.0f)
+            func_004757A0((f32 *)((u32)index * 4 + (u32)&D_002211E0), state->fDC.value, state->fD4);
+        else
+            func_004757A0((f32 *)((u32)index * 4 + (u32)&D_002211E0), state->fDC.value, state->fD8);
+        if (*(f32 *)((u32)index * 4 + (u32)&D_002211E0) == state->fDC.value) {
+            if (func_004534D0(&state->fE0) == 1)
+                state->fDC.bits = 0;
+        }
+        if (state->fDC.value <= 0.0f && *(f32 *)((u32)index * 4 + (u32)&D_002211E0) <= 0.0f)
+            state->fD4 = 0.0f;
+    }
+}
diff --git a/src/game/004473C0.c b/src/game/004473C0.c
new file mode 100644
index 000000000..a14005e83
--- /dev/null
+++ b/src/game/004473C0.c
@@ -0,0 +1,44 @@
+#include "common.h"
+
+extern u8 *D_0022131C;
+
+u8 *func_004473C0(s32 x, s32 y, s32 z)
+{
+    u8 *base = D_0022131C;
+    u8 *data = base + *(s32 *)base;
+    u16 *node = (u16 *)(base + 4);
+    s32 iz;
+    s32 iy;
+    s32 ix;
+
+    iz = z - node[0];
+    if (iz < 0) {
+        return 0;
+    }
+    if (!(iz < node[1])) {
+        return 0;
+    }
+    if (!node[iz + 2]) {
+        return 0;
+    }
+    node = (u16 *)(base + node[iz + 2] * 4);
+    iy = y - node[0];
+    if (iy < 0) {
+        return 0;
+    }
+    if (!(iy < node[1])) {
+        return 0;
+    }
+    if (!node[iy + 2]) {
+        return 0;
+    }
+    node = (u16 *)(base + node[iy + 2] * 4);
+    ix = x - node[0];
+    if (ix < 0 || !(ix < node[1])) {
+        return 0;
+    }
+    if (node[ix + 2] == 0xFFFF) {
+        return 0;
+    }
+    return data + node[ix + 2] * 128;
+}
diff --git a/src/game/00448B40.c b/src/game/00448B40.c
new file mode 100644
index 000000000..40f4b70d0
--- /dev/null
+++ b/src/game/00448B40.c
@@ -0,0 +1,20 @@
+#include "common.h"
+
+typedef struct Display {
+    u8 fields[0x150];
+    s16 width;
+    s16 height;
+} Display;
+
+extern Display D_00206A40;
+extern char *func_00448A20(s32 index);
+
+void func_00448B40(s32 index, s32 *left, s32 *top, s32 *right, s32 *bottom)
+{
+    f32 *rectangle = (f32 *)func_00448A20(index);
+
+    *left = (s32)((f32)D_00206A40.width * rectangle[0]);
+    *top = (s32)((f32)D_00206A40.height * rectangle[2]);
+    *right = (s32)((f32)D_00206A40.width * rectangle[1]);
+    *bottom = (s32)((f32)D_00206A40.height * rectangle[3]);
+}
diff --git a/src/game/00448D98.c b/src/game/00448D98.c
new file mode 100644
index 000000000..a91a6504f
--- /dev/null
+++ b/src/game/00448D98.c
@@ -0,0 +1,34 @@
+/* cflags: -fno-schedule-insns */
+#include "common.h"
+
+extern u8 *D_00221E20;
+extern u8 *D_00221200;
+extern u8 *D_002211FC;
+extern void func_00469968(void);
+extern u8 *func_004E7B88(void);
+
+void func_00448D98(void)
+{
+    s32 tag;
+    u8 *packet;
+
+    D_00221200 = D_00221E20;
+    tag = 0x20000000;
+    D_00221E20 += 16;
+    *(s32 *)D_002211FC = tag;
+    packet = D_002211FC;
+    *(u8 **)(packet + 4) = D_00221E20;
+    *(s32 *)(D_002211FC + 8) = 0;
+    *(s32 *)(D_002211FC + 12) = 0;
+    func_00469968();
+    func_004E7B88();
+    *(s32 *)D_00221E20 = tag;
+    *(u8 **)(D_00221E20 + 4) = D_002211FC + 16;
+    *(s32 *)(D_00221E20 + 8) = 0;
+    *(s32 *)(D_00221E20 + 12) = 0;
+    D_00221E20 += 16;
+    *(s32 *)D_00221200 = tag;
+    *(u8 **)(D_00221200 + 4) = D_00221E20;
+    *(s32 *)(D_00221200 + 8) = 0;
+    *(s32 *)(D_00221200 + 12) = 0;
+}
diff --git a/src/game/0044A410.c b/src/game/0044A410.c
new file mode 100644
index 000000000..0a90583d3
--- /dev/null
+++ b/src/game/0044A410.c
@@ -0,0 +1,60 @@
+#include "common.h"
+
+extern s32 D_001D3F40[];
+extern s32 D_00221E20;
+extern s32 D_00221270;
+extern s32 func_0044DF08(s32, u32, s64);
+
+s32 func_0044A410(s32 arg0, s32 arg1, s32 arg2, s32 arg3, u64 arg4, u64 arg5, s32 arg6, f32 f12, f32 f13, f32 f14, f32 f15) {
+    s32 x0;
+    s32 x1;
+    s32 y0;
+    s32 y1;
+    s32 end1;
+    s32 buffer;
+    u64 first;
+    u64 packet0;
+    u64 packet1;
+    u64 packet2;
+    u64 packet3;
+    u64 packet4;
+    f32 scale = 16.0f;
+
+    f14 = (f12 + f14) * scale;
+    f15 = (f13 + f15) * scale;
+    f12 *= scale;
+    f13 *= scale;
+    x0 = (s32)f14 + D_001D3F40[4] - 8;
+    x1 = (s32)f12 + D_001D3F40[4] - 8;
+    y0 = (s32)f13 + D_001D3F40[5] - 8;
+    y1 = (s32)f15 + D_001D3F40[5] - 8;
+    if (x1 > 0x9000 || x0 < 0x7000 || y0 > 0x9000 || y1 < 0x7000) {
+        return 0;
+    }
+    if (arg6 != 0) {
+        x1 = (x1 & 0xFFF0) + 8;
+        x0 = (x0 & 0xFFF0) + 8;
+        y0 = (y0 & 0xFFF0) + 8;
+        y1 = (y1 & 0xFFF0) + 8;
+    }
+    end1 = arg1 + arg3;
+    first = ((u64)(arg0 + arg2 - 1) << 14) | 0xA;
+    packet0 = ((u64)arg0 << 4) | first |
+              ((u64)arg1 << 24) | ((u64)(end1 - 1) << 34);
+    packet2 = (u64)(arg1 << 20) | (u64)(arg0 << 4);
+    packet3 = (u64)x1 | ((u64)y0 << 16);
+    packet4 = (u64)(end1 << 20) | (u64)((arg0 + arg2) << 4);
+    packet1 = (u64)x0 | ((u64)y1 << 16);
+    buffer = D_00221E20;
+    *(u64 *)(buffer + 0x38) = packet1;
+    *(u64 *)(buffer + 0x10) = packet0;
+    *(u64 *)(buffer + 8) = 0x156;
+    *(u64 *)(buffer + 0x18) = (u64)arg4;
+    *(u64 *)(buffer + 0x20) = packet2;
+    *(u64 *)(buffer + 0x28) = packet3;
+    *(u64 *)(buffer + 0x30) = packet4;
+    *(u64 *)buffer = (u64)arg5;
+    D_00221E20 += 0x40;
+    func_0044DF08((s32)&D_00221270, 6, arg5);
+    return 1;
+}
diff --git a/src/game/0044AA58.c b/src/game/0044AA58.c
new file mode 100644
index 000000000..f48ec6404
--- /dev/null
+++ b/src/game/0044AA58.c
@@ -0,0 +1,28 @@
+#include "common.h"
+
+typedef int Quad __attribute__((mode(TI)));
+extern u8 *D_00221E20;
+extern Quad D_0021FF60;
+void func_0044AA58(const u64 *coordinates, const s32 *values)
+{
+    u8 *first, *next, *cursor;
+    *(u32 *)(D_00221E20 + 0) = 0x10000005;
+    *(u32 *)(D_00221E20 + 4) = 0;
+    *(u32 *)(D_00221E20 + 8) = 0;
+    *(u32 *)(D_00221E20 + 12) = 0x50000005;
+    cursor = (u8 *)D_00221E20;
+    D_00221E20 = cursor + 16;
+    *(Quad *)(cursor + 16) = D_0021FF60;
+    first = (u8 *)D_00221E20;
+    next = first + 16;
+    D_00221E20 = next;
+    *(u64 *)(first + 16) = 0x4C;
+    *(u64 *)(next + 8) = (s64)values[0];
+    *(u64 *)(next + 16) = coordinates[0];
+    *(u64 *)(next + 24) = coordinates[2];
+    *(u64 *)(next + 32) = (s64)values[1];
+    *(u64 *)(next + 40) = coordinates[1];
+    *(u64 *)(next + 48) = coordinates[3];
+    *(u64 *)(next + 56) = 0;
+    D_00221E20 += 64;
+}
diff --git a/src/game/0044ABC0.c b/src/game/0044ABC0.c
new file mode 100644
index 000000000..1eb32d897
--- /dev/null
+++ b/src/game/0044ABC0.c
@@ -0,0 +1,14 @@
+#include "common.h"
+
+extern void func_00449E98(s32, s32, s32, s32, u64);
+void func_0044ABC0(s32 x, s32 y, s32 width, s32 extent, s32 alpha, s32 rgb)
+{
+    s32 color = (s32)(((u32)alpha << 24) | (u32)rgb);
+    func_00449E98(x, y, width, extent, color);
+    func_00449E98(x + 1, y - 1, width - 2, width, color);
+    func_00449E98(x + 2, y - 2, width - 3, width - 2, color);
+    func_00449E98(x + 4, y - 4, width - 4, width - 3, color);
+    func_00449E98(x + 1, y - 1, extent, extent + 2, color);
+    func_00449E98(x + 2, y - 2, extent + 2, extent + 3, color);
+    func_00449E98(x + 4, y - 4, extent + 3, extent + 4, color);
+}
diff --git a/src/game/0044D6D0.c b/src/game/0044D6D0.c
new file mode 100644
index 000000000..913bd6c13
--- /dev/null
+++ b/src/game/0044D6D0.c
@@ -0,0 +1,53 @@
+#include "common.h"
+
+typedef struct State {
+    u8 enabled;
+    u8 unknown1[3];
+    s32 index;
+    s32 selected;
+    s32 selector;
+    u8 unknown10[8];
+    u64 primary_key;
+    u64 current;
+    u64 current_secondary;
+    u64 key30;
+    u64 key38;
+    u8 unknown40[8];
+    u64 key48;
+} State;
+typedef struct Entry {
+    u8 prefix[0x10];
+    u64 value;
+    u8 tail[8];
+} Entry;
+extern State D_00239540;
+extern Entry D_003D7B00[];
+extern u32 *D_00221E20;
+void func_0044D6D0(void *unused, s32 id)
+{
+    if (D_00239540.enabled == 0) {
+        if (id == 0)
+            return;
+        D_00221E20[0] = 0x30000002;
+        D_00221E20[1] = (u32)&D_003D7B00[id];
+        D_00221E20[2] = 0;
+        D_00221E20[3] = 0x50000002;
+        D_00221E20 += 4;
+        return;
+    }
+    if (id == 0)
+        return;
+    if (D_00239540.selected != id && D_00239540.current == D_003D7B00[id].value) {
+        D_00239540.selected = id;
+        return;
+    }
+    if (D_00239540.current == D_003D7B00[id].value)
+        return;
+    D_00221E20[0] = 0x30000002;
+    D_00221E20[1] = (u32)&D_003D7B00[id];
+    D_00221E20[2] = 0;
+    D_00221E20[3] = 0x50000002;
+    D_00239540.selected = id;
+    D_00239540.current = D_003D7B00[id].value;
+    D_00221E20 += 4;
+}
diff --git a/src/game/0044DF08.c b/src/game/0044DF08.c
new file mode 100644
index 000000000..b9f9fcddc
--- /dev/null
+++ b/src/game/0044DF08.c
@@ -0,0 +1,109 @@
+#include "common.h"
+
+extern u8 D_00239540[];
+
+s32 func_0044DF08(s32 arg0, u32 arg1, s64 arg2) {
+    s32 base = (s32)D_00239540;
+    s32 result;
+    s64 value;
+
+    if (D_00239540[0] != 0) {
+        goto dispatch;
+    }
+    return 1;
+dispatch:
+    if (arg1 == 0x3D) {
+        goto case28;
+    }
+    if (arg1 < 0x3E) {
+        if (arg1 == 8) {
+            goto case20;
+        }
+        if (arg1 < 9) {
+            if (arg1 == 6) {
+                goto case40;
+            }
+            result = 1;
+            goto done;
+        }
+        if (arg1 == 0x14) {
+            goto case38;
+        }
+        result = 1;
+        goto done;
+    }
+    if (arg1 == 0x47) {
+        goto case30;
+    }
+    if (arg1 < 0x48) {
+        if (arg1 == 0x42) {
+            goto case18;
+        }
+        result = 1;
+        goto done;
+    }
+    if (arg1 == 0x4E) {
+        goto case48;
+    }
+    result = 1;
+    goto done;
+case18:
+    value = *(s64 *)(base + 0x18);
+    if (value == arg2) {
+        goto equal;
+    }
+    *(s64 *)(base + 0x18) = arg2;
+    *(s32 *)(base + 0x4) = -1;
+    goto success;
+case30:
+    value = *(s64 *)(base + 0x30);
+    if (value == arg2) {
+        goto equal;
+    }
+    *(s64 *)(base + 0x30) = arg2;
+    *(s32 *)(base + 0x4) = -1;
+    goto success;
+case20:
+    value = *(s64 *)(base + 0x20);
+    if (value == arg2) {
+        goto equal;
+    }
+    *(s64 *)(base + 0x20) = arg2;
+    *(s32 *)(base + 0x8) = -1;
+    goto success;
+case40:
+    value = *(s64 *)(base + 0x40);
+    if (value != arg2) {
+        goto update40;
+    }
+    goto equal;
+equal:
+    return 0;
+update40:
+    *(s64 *)(base + 0x40) = arg2;
+    *(s32 *)(base + 0x10) = 0x7C;
+    goto success;
+case38:
+    if (*(s64 *)(base + 0x38) == arg2) {
+        goto equal;
+    }
+    *(s64 *)(base + 0x38) = arg2;
+    goto success;
+case48:
+    value = *(s64 *)(base + 0x48);
+    if (value == arg2) {
+        goto equal;
+    }
+    *(s64 *)(base + 0x48) = arg2;
+    goto success;
+case28:
+    value = *(s64 *)(base + 0x28);
+    if (value == arg2) {
+        goto equal;
+    }
+    *(s64 *)(base + 0x28) = arg2;
+success:
+    result = 1;
+done:
+    return result;
+}
diff --git a/src/game/00452598.c b/src/game/00452598.c
new file mode 100644
index 000000000..418e52314
--- /dev/null
+++ b/src/game/00452598.c
@@ -0,0 +1,25 @@
+#include "common.h"
+
+extern s32 D_0021DDB8;
+extern void func_004512D0(s32, s32 *, s32, s32, s32);
+
+void func_00452598(s32 arg0, s32 *state, s32 arg2, s32 arg3, s32 arg4, s32 arg5)
+{
+    s32 i;
+    s32 *entry;
+    state[0xA8 / 4] = D_0021DDB8;
+    state[0xAC / 4] = 0;
+    for (i = 0; i < 32 && state[i + 4] != 0; i++) {
+        entry = (s32 *)state[i + 4];
+        func_004512D0(arg0, entry, arg2, arg3, arg4);
+        *(u8 *)((u8 *)entry + 0xB) = 1;
+    }
+    state[0xA4 / 4] = i;
+    if (arg5 != 0) {
+        *(f32 *)((u8 *)state + 0x90) = 1.0f;
+        *(f32 *)((u8 *)state + 0x94) = 1.0f;
+        state[0x98 / 4] = 0;
+        state[0x9C / 4] = 0;
+        *(f32 *)((u8 *)state + 0xA0) = 1.0f;
+    }
+}
diff --git a/src/game/00454420.c b/src/game/00454420.c
new file mode 100644
index 000000000..c30f85154
--- /dev/null
+++ b/src/game/00454420.c
@@ -0,0 +1,38 @@
+#include "common.h"
+
+typedef struct {
+    u32 first;
+    u32 metrics;
+} Glyph;
+extern Glyph *D_0021DE8C;
+extern s32 func_00454400(void);
+s32 func_00454420(f32 *width, f32 *height, s32 mode)
+{
+    s32 result;
+    *width = 0.0f;
+    *height = 0.0f;
+    result = 0;
+    if (D_0021DE8C != 0) {
+        if (mode != 0) {
+            *width = (f32)((D_0021DE8C[0x41].metrics >> 17) & 0x3F);
+            *height = (f32)((D_0021DE8C[0x41].metrics >> 9) & 0xFF) * 0.25f;
+            result = 1;
+        } else {
+            s32 count = func_00454400();
+            if (count > 0) {
+                s32 i;
+                u32 maximum = 0;
+                for (i = 0; i < count; i++) {
+                    u32 current = (D_0021DE8C[i].metrics >> 17) & 0x3F;
+                    if (maximum < current) {
+                        maximum = current;
+                        *height = (f32)((D_0021DE8C[i].metrics >> 9) & 0xFF) * 0.25f;
+                    }
+                }
+                *width = (f32)maximum;
+                result = 1;
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/game/00454600.c b/src/game/00454600.c
new file mode 100644
index 000000000..17998e9f8
--- /dev/null
+++ b/src/game/00454600.c
@@ -0,0 +1,30 @@
+/* cflags: -mno-split-addresses */
+#include "common.h"
+
+typedef struct {
+    u32 first;
+    u32 metrics;
+} Glyph;
+extern Glyph *D_0021DE8C[];
+extern s32 func_00454258(const u8 *, s32, s32 *);
+s32 func_00454600(const u8 *text, s32 length, f32 scale)
+{
+    s32 offset = 0;
+    s32 running = 1;
+    f32 maximum = 0.0f;
+    s32 glyph = 0;
+    for (; running && offset != length; offset++) {
+        if (text[offset] == 0) {
+            running = 0;
+        } else {
+            f32 width, height, value;
+            offset += func_00454258(text, offset, &glyph);
+            width = (f32)((D_0021DE8C[0][glyph].metrics >> 17) & 0x3F) * scale;
+            height = (f32)((D_0021DE8C[0][glyph].metrics >> 9) & 0xFF) * scale;
+            value = width + height * 0.25f;
+            if (maximum < value)
+                maximum = value;
+        }
+    }
+    return (s32)maximum;
+}
diff --git a/src/game/004597B8.c b/src/game/004597B8.c
new file mode 100644
index 000000000..3626eb341
--- /dev/null
+++ b/src/game/004597B8.c
@@ -0,0 +1,25 @@
+#include "common.h"
+
+extern u32 *D_00221E20;
+extern u8 D_003D9FB0[], D_003D9FD0[], D_0020BF10[], D_003D9F40[];
+void func_004597B8(s32 alternate)
+{
+    D_00221E20[0] = 0x30000002;
+    if (alternate)
+        D_00221E20[1] = (u32)D_003D9FB0;
+    else
+        D_00221E20[1] = (u32)D_003D9FD0;
+    D_00221E20[2] = 0;
+    D_00221E20[3] = 0x50000002;
+    D_00221E20 += 4;
+    D_00221E20[0] = 0x30000029;
+    D_00221E20[1] = (u32)D_0020BF10;
+    D_00221E20[2] = 0;
+    D_00221E20[3] = 0x50000029;
+    D_00221E20 += 4;
+    D_00221E20[0] = 0x30000003;
+    D_00221E20[1] = (u32)D_003D9F40;
+    D_00221E20[2] = 0;
+    D_00221E20[3] = 0x50000003;
+    D_00221E20 += 4;
+}
diff --git a/src/game/0045D108.c b/src/game/0045D108.c
new file mode 100644
index 000000000..c2efdc01f
--- /dev/null
+++ b/src/game/0045D108.c
@@ -0,0 +1,26 @@
+#include "common.h"
+typedef struct {
+    int f0, f4, f8, fC, f10, f14, f18;
+    unsigned int f1C;
+    short f20, f22, f24;
+    unsigned char f26, f27;
+} State;
+extern State D_0023F280[];
+extern short D_0023F2A8[];
+void func_0045D108(void)
+{
+    D_0023F280[0].f0 = 0;
+    D_0023F280[0].f4 = 0;
+    D_0023F280[0].f8 = -1;
+    D_0023F280[0].fC = -1;
+    D_0023F280[0].f14 = -1;
+    D_0023F280[0].f1C = 0xFFFFFFFFu;
+    D_0023F280[0].f20 = 0x78;
+    D_0023F280[0].f26 = 0;
+    D_0023F280[0].f27 = 0;
+    D_0023F280[0].f24 = 0;
+    D_0023F280[0].f22 = 0;
+    D_0023F2A8[0] = 0;
+    D_0023F2A8[1] = 0;
+    D_0023F2A8[2] = 0;
+}
diff --git a/src/game/0045E860.c b/src/game/0045E860.c
new file mode 100644
index 000000000..12ea84680
--- /dev/null
+++ b/src/game/0045E860.c
@@ -0,0 +1,63 @@
+#include "common.h"
+
+typedef struct {
+    u32 address;
+    u32 unknown4;
+} HudEntry;
+
+typedef struct {
+    u8 unknown0[12];
+    u8 *header;
+    u8 unknown10[8];
+    HudEntry *table2;
+    HudEntry *table1;
+} HudState;
+
+typedef struct {
+    u8 unknown0[0x14];
+    s32 limits[0];
+} HudLimits1;
+
+typedef struct {
+    u8 unknown0[0x34];
+    s32 limits[0];
+} HudLimits2;
+
+extern HudState D_0023F430;
+
+void func_0045E860(s32 bank, u32 address)
+{
+    u32 *banks;
+    u32 *slot;
+    s32 first;
+    s32 limit;
+    s32 i;
+
+    banks = (u32 *)(D_0023F430.header + 0x74);
+    slot = &banks[bank];
+    if (*slot != 0) {
+        return;
+    }
+    address = (address + 15) & 0xFFFFFFF0;
+    *slot = address;
+    if (bank != 0) {
+        first = ((HudLimits1 *)D_0023F430.header)->limits[bank - 1];
+    } else {
+        first = 0;
+    }
+    limit = ((HudLimits1 *)D_0023F430.header)->limits[bank];
+    for (i = first; i < limit; i++) {
+        D_0023F430.table1[i].address &= 0x7FFFFFFF;
+        D_0023F430.table1[i].address += address;
+    }
+    if (bank != 0) {
+        first = ((HudLimits2 *)D_0023F430.header)->limits[bank - 1];
+    } else {
+        first = 0;
+    }
+    limit = ((HudLimits2 *)D_0023F430.header)->limits[bank];
+    for (i = first; i < limit; i++) {
+        D_0023F430.table2[i].address &= 0x7FFFFFFF;
+        D_0023F430.table2[i].address += address;
+    }
+}
diff --git a/src/game/00460B00.c b/src/game/00460B00.c
new file mode 100644
index 000000000..526a23074
--- /dev/null
+++ b/src/game/00460B00.c
@@ -0,0 +1,45 @@
+#include "common.h"
+
+typedef struct Descriptor {
+    u32 unknown0;
+    s32 limit;
+} Descriptor;
+extern u32 D_00206DD8[];
+extern const char D_0021EF38[];
+extern const char D_003D0738[];
+extern const char D_0021EF40[];
+extern const char D_0021EF48[];
+extern const char D_0021EF50[];
+extern const char D_003D0750[];
+extern const char D_0021EF58[];
+extern const char D_0021EF68[];
+extern const char D_003D0768[];
+extern void func_00460558(u32 *registry, s32 count);
+extern void func_004605A8(u32 *registry, const char *name, void *owner,
+                          Descriptor *descriptor, u32 cost, u32 bytes,
+                          const void *data, s32 id);
+extern void func_004608E8(u32 *registry, s32 count, const char *label);
+
+void func_00460B00(u8 *owner)
+{
+    u32 *registry = D_00206DD8;
+
+    func_00460558(registry, 1);
+    func_004605A8(registry, D_0021EF38, owner, (Descriptor *)(owner + 8),
+                  0x1A00, 0, 0, 1);
+    func_004605A8(registry, D_003D0738, owner, (Descriptor *)(owner + 0x28),
+                  0x3100, 0, 0, 2);
+    func_004605A8(registry, D_0021EF40, owner, (Descriptor *)(owner + 0x10),
+                  0x27500, 0, 0, 3);
+    func_004605A8(registry, D_0021EF48, owner, (Descriptor *)(owner + 0x18),
+                  0x4800, 0, 0, 4);
+    func_004605A8(registry, D_0021EF50, owner, (Descriptor *)(owner + 0x20),
+                  0x1C200, 0, 0, 5);
+    func_004605A8(registry, D_003D0750, owner, (Descriptor *)(owner + 0x30),
+                  0x5E00, 0, 0, 6);
+    func_004605A8(registry, D_0021EF58, owner, (Descriptor *)(owner + 0x38),
+                  0x2B200, 0, 0, 7);
+    func_004605A8(registry, D_0021EF68, owner, (Descriptor *)(owner + 0xC0),
+                  0x1400, 0, 0, 9);
+    func_004608E8(registry, 1, D_003D0768);
+}
diff --git a/src/game/00460D48.c b/src/game/00460D48.c
new file mode 100644
index 000000000..004397b30
--- /dev/null
+++ b/src/game/00460D48.c
@@ -0,0 +1,76 @@
+#include "common.h"
+
+extern u8 D_0021DD52;
+extern u8 D_0021DD53;
+extern u8 D_0021DD54;
+extern u8 D_00209148[];
+extern char D_0021EF70[];
+extern char D_003D0780[];
+extern u8 D_003D0798[];
+extern char D_0021EF80[];
+extern u8 D_003D07D8[];
+extern char D_0021EF20[];
+extern char D_003D07F0[];
+extern char D_0021EF90[];
+extern char D_003D0808[];
+extern char D_003D0820[];
+extern char D_0021EFA0[];
+extern u8 D_0021EFA8[];
+extern char D_0021EFB8[];
+extern u8 D_003D0838[];
+extern char D_0021EFC8[];
+extern char D_0021EFD8[];
+extern u8 D_003D0868[];
+extern char D_0021EFE0[];
+extern u8 D_0021EFE8[];
+extern char D_0021EFF8[];
+extern char D_003D0888[];
+
+extern void func_00460558(void *menu, s32 count);
+extern void func_004605A8(void *menu, const char *label, void *owner,
+                          void *stats, s32 bytes, s32 dataSize,
+                          const void *data, s32 kind);
+extern void func_004608E8(void *menu, s32 count, const char *title);
+extern s32 func_004600C0(u32 mask, s32 mode);
+
+void func_00460D48(u8 *stats)
+{
+    u8 *menu;
+
+    if (D_0021DD52 || D_0021DD54 || D_0021DD53) {
+        return;
+    }
+    menu = D_00209148;
+    func_00460558(menu, 1);
+    func_004605A8(menu, D_0021EF70, stats, stats + 0x48,
+                  0x40E00, 0, 0, 14);
+    func_004605A8(menu, D_003D0780, stats, stats + 0x50,
+                  0xCD00, 62, D_003D0798, 12);
+    func_004605A8(menu, D_0021EF80, stats, stats + 0x58,
+                  0x9100, 18, D_003D07D8, 15);
+    func_004605A8(menu, D_0021EF20, stats, stats + 0x68,
+                  0x2900, 0, 0, 10);
+    func_004605A8(menu, D_003D07F0, stats, stats + 0x70,
+                  0x8600, 0, 0, 19);
+    func_004605A8(menu, D_0021EF90, stats, stats + 0x80,
+                  0x18B00, 0, 0, 16);
+    func_004605A8(menu, D_003D0808, stats, stats + 0x88,
+                  0x7500, 0, 0, 17);
+    func_004605A8(menu, D_003D0820, stats, stats + 0x60,
+                  0x2600, 0, 0, 11);
+    func_004605A8(menu, D_0021EFA0, stats, stats + 0x78,
+                  0x6100, 14, D_0021EFA8, 18);
+    func_004605A8(menu, D_0021EFB8, stats, stats + 0x90,
+                  0x15F00, 43, D_003D0838, 20);
+    func_004605A8(menu, D_0021EFC8, stats, stats + 0xA0,
+                  0x3000, 0, 0, 13);
+    func_004605A8(menu, D_0021EFD8, stats, stats + 0xB0,
+                  0x2A00, 28, D_003D0868, 21);
+    func_004605A8(menu, D_0021EFE0, stats, stats + 0x98,
+                  0xCC00, 15, D_0021EFE8, 22);
+    func_004605A8(menu, D_0021EFF8, stats, stats + 0xA8,
+                  0x3500, 0, 0, 23);
+    func_004608E8(menu, 1, D_003D0888);
+    func_004600C0(0x8000, 3);
+    D_0021DD54 = 1;
+}
diff --git a/src/game/00462D68.c b/src/game/00462D68.c
new file mode 100644
index 000000000..7c4cb6fd3
--- /dev/null
+++ b/src/game/00462D68.c
@@ -0,0 +1,36 @@
+#include "common.h"
+
+typedef struct {
+    s32 *data;
+    s32 packed_count;
+    s32 reserved[2];
+} Group;
+extern void func_00462608(void *, const void *, s32, s32, s32, s32, s32);
+extern void func_00462910(void *, s32, s32, s32, s32, s32);
+void func_00462D68(Group *groups, const u8 *palette, const u8 *mapping, s32 count)
+{
+    s32 i, j, group_count, offset, index;
+    s32 *entry;
+    Group *group = groups;
+    Group *next;
+    for (i = 0; i < count; i++) {
+        next = group + 1;
+        group_count = group->packed_count >> 16;
+        offset = group->packed_count & 0xFFFF;
+        group->packed_count = offset;
+        entry = (s32 *)((u32)group->data + (u32)((offset - group_count) * 16));
+        for (j = 0; j < group_count; j += 4) {
+            index = entry[8];
+            if (index >= 0)
+                index = mapping[index];
+            if (palette) {
+                func_00462608(entry, (const void *)((u32)palette + (u32)(index * 16)),
+                              entry[0], entry[1], entry[4], entry[5], index);
+            } else {
+                func_00462910(entry, entry[0], entry[1], entry[4], entry[5], index);
+            }
+            entry += 16;
+        }
+        group = next;
+    }
+}
diff --git a/src/game/00463B78.c b/src/game/00463B78.c
new file mode 100644
index 000000000..9dbf317cc
--- /dev/null
+++ b/src/game/00463B78.c
@@ -0,0 +1,43 @@
+#include "common.h"
+
+typedef struct {
+    u8 p0[0x8C];
+    u16 count;
+    u8 p8E[0x12];
+    u8 *source, *end;
+    u8 pA8[0x14];
+    u8 *buffer;
+} State;
+extern State D_00237000[];
+typedef union {
+    s32 word;
+    u16 half;
+} Counter;
+extern Counter D_00266760[];
+extern u32 func_00469C40(const void *, void *);
+extern void func_00453808(void *, const void *, u32);
+extern void func_004640A0(s32, void *, void *, s32, s32);
+void func_00463B78(void)
+{
+    u32 size = func_00469C40(D_00237000[0].buffer, D_00237000[0].source);
+    u8 *base = (u8 *)((u32)D_00237000[0].end - size);
+    s32 *record;
+    s32 first, before;
+    func_00453808(base, D_00237000[0].source, size);
+    D_00237000[0].buffer = base;
+    D_00237000[0].end = base;
+    record = (s32 *)base;
+    first = *record++;
+    before = D_00266760[0].word;
+    while (first >= 0) {
+        s32 offset = *record++;
+        s32 other = record[0];
+        void *optional = 0;
+        record += 2;
+        if (offset)
+            optional = (void *)((u32)D_00237000[0].buffer + (u32)offset);
+        func_004640A0(first, (void *)((u32)D_00237000[0].buffer + (u32)other), optional, 0, 1);
+        first = *record++;
+    }
+    D_00237000[0].count = D_00266760[0].half - before;
+}
diff --git a/src/game/004653A8.c b/src/game/004653A8.c
new file mode 100644
index 000000000..0e032b17e
--- /dev/null
+++ b/src/game/004653A8.c
@@ -0,0 +1,34 @@
+#include "common.h"
+
+extern s32 func_00464AF8(s32);
+extern s32 D_00171948[];
+extern s32 D_0021DAE4;
+
+s32 D_0021F1D0 = -1;
+void (*D_0021F1E8)(void) = 0;
+
+void func_004653A8(void)
+{
+    if (D_00171948[113] != 2) {
+        return;
+    }
+    if (D_00171948[115] >= 0) {
+        return;
+    }
+    if (D_00171948[117] != 0) {
+        func_00464AF8(20);
+    } else {
+        D_00171948[108] = 0;
+        ((u16 *)D_00171948)[12] = 0;
+        if (D_0021DAE4 & 0x1000) {
+            ((u16 *)D_00171948)[12] = D_0021F1D0;
+            D_0021DAE4 &= -0x1001;
+            D_0021F1D0 = -1;
+        }
+        func_00464AF8(18);
+    }
+    if (D_0021F1E8 != 0) {
+        D_0021F1E8();
+        D_0021F1E8 = 0;
+    }
+}
diff --git a/src/game/004655A0.c b/src/game/004655A0.c
new file mode 100644
index 000000000..bd730131a
--- /dev/null
+++ b/src/game/004655A0.c
@@ -0,0 +1,32 @@
+#include "common.h"
+
+typedef struct State {
+    u8 unknown0[8];
+    s32 mode;
+    u32 unknownC;
+    s32 active;
+    u8 unknown14[0x1D0];
+    s32 pending;
+} State;
+
+extern State D_00171948[];
+extern s32 D_0021EDD4;
+extern u32 D_0021DAE4;
+extern void func_00464AF8(s32 state);
+
+void func_004655A0(void)
+{
+    if (D_00171948[0].mode != 2) {
+        func_00464AF8(4);
+    } else if (!D_0021EDD4 && D_00171948[0].pending) {
+        func_00464AF8(1);
+    } else if (D_0021DAE4 & 4) {
+        func_00464AF8(30);
+    } else if (D_0021DAE4 & 2) {
+        func_00464AF8(29);
+    } else if (D_0021DAE4 & 0x800) {
+        func_00464AF8(12);
+    } else if (D_00171948[0].mode == 2 && D_00171948[0].active) {
+        func_00464AF8(5);
+    }
+}
diff --git a/src/game/00465F38.c b/src/game/00465F38.c
new file mode 100644
index 000000000..9a7c99d7a
--- /dev/null
+++ b/src/game/00465F38.c
@@ -0,0 +1,31 @@
+#include "common.h"
+extern char D_00171830[], D_00171848[], D_00171860[], D_00171878[], D_00171898[];
+extern char D_001718B8[], D_001718E8[], D_00171908[], D_00171928[];
+extern char *func_0011AFC8(char *, const char *, u32);
+void func_00465F38(const u8 *header)
+{
+    s32 i;
+    u8 region;
+    func_0011AFC8(D_00171830, (const char *)header + 8, 21);
+    region = header[0x12];
+    if (region == 'E')
+        D_00171848[2] = region;
+    else if (region == 'P')
+        D_00171848[2] = 'I';
+    else if (region == 'K')
+        D_00171848[2] = region;
+    for (i = 3; i < 7; ++i)
+        D_00171848[i] = header[i + 0xD];
+    for (i = 8; i < 11; ++i)
+        D_00171848[i] = header[i + 0xD];
+    for (i = 11; i < 13; ++i)
+        D_00171848[i] = header[i + 0xE];
+    func_0011AFC8(D_00171860, D_00171848, 13);
+    func_0011AFC8(D_00171878, D_00171848, 13);
+    func_0011AFC8(D_00171898, D_00171848, 13);
+    func_0011AFC8(D_001718B8, D_00171848, 13);
+    func_0011AFC8(D_001718B8 + 20, D_00171848, 13);
+    func_0011AFC8(D_001718E8, D_00171848, 13);
+    func_0011AFC8(D_00171928, D_00171848, 13);
+    func_0011AFC8(D_00171908, D_00171848, 13);
+}
diff --git a/src/game/004660F8.c b/src/game/004660F8.c
new file mode 100644
index 000000000..b3d751e34
--- /dev/null
+++ b/src/game/004660F8.c
@@ -0,0 +1,31 @@
+#include "common.h"
+
+typedef struct {
+    s32 type, size, offset, state;
+} Descriptor;
+extern Descriptor D_003D80F0[], D_003D82D0[];
+extern s32 func_00468B40(const Descriptor *);
+extern s32 func_00468E58(const u8 *, const u8 *, s32, Descriptor *);
+extern void func_004694B0(void);
+void func_004660F8(const u8 *packet)
+{
+    s32 first = func_00468B40(D_003D80F0);
+    s32 second = func_00468B40(D_003D82D0);
+    s32 index;
+    const u8 *next;
+    s32 storedFirst = *(const s32 *)packet;
+    if (storedFirst == first && *(const s32 *)(packet + 4) == second) {
+        packet += 8;
+        next = packet + storedFirst;
+        func_00468E58(packet, next, 0, D_003D80F0);
+        packet = next;
+        index = 0;
+        do {
+            const u8 *end = packet + second;
+            func_00468E58(packet, end, index, D_003D82D0);
+            index++;
+            packet = end;
+        } while (index < 15);
+        func_004694B0();
+    }
+}
diff --git a/src/game/004661D8.c b/src/game/004661D8.c
new file mode 100644
index 000000000..5aaddefca
--- /dev/null
+++ b/src/game/004661D8.c
@@ -0,0 +1,48 @@
+#include "common.h"
+
+extern s32 D_0021EDD4;
+extern s32 D_001C2040[];
+extern u8 D_001711D0[];
+extern u8 D_00171D38[];
+extern s32 D_0021DE10;
+extern s32 D_00171948[];
+extern void func_0045C670(s32, void *);
+extern void func_00489C28(s32);
+extern void func_001634A8(s32);
+extern s32 func_00163808(s32, s32, s32, s32, s32, s32, s32);
+extern void func_00453718(void *, const void *, u32);
+extern void func_004660F8(s32);
+extern void func_00465DF8(s32);
+
+void func_004661D8(void) {
+    u8 workspace[0x110];
+    u8 *output;
+    s32 arg;
+    s32 value;
+    s32 *state;
+    if (D_0021EDD4 == 1) {
+        return;
+    }
+    output = workspace + 0x100;
+    state = D_001C2040;
+    func_0045C670(state[0x664 / 4] << 11, output);
+    func_00489C28(1);
+    func_001634A8(1);
+    arg = state[0x660 / 4] + state[0x64C / 4];
+    func_00163808(0, *(s32 *)output, arg, state[0x664 / 4], 0, 0, 0);
+    value = *(s32 *)output;
+    value += *(s32 *)(value + 0x10);
+    func_00453718(workspace, D_001711D0, 0x28);
+    func_00453718(workspace + 0x30, D_00171D38, 0xC4);
+    func_004660F8(value);
+    func_00453718(D_001711D0, workspace, 0x28);
+    func_00453718(D_00171D38, workspace + 0x30, 0xC4);
+    D_0021DE10 = 1;
+    if (D_00171948[0x1E4 / 4] != 0) {
+        D_00171948[0x1E4 / 4] = 0;
+    }
+    if (*(s16 *)((u8 *)D_00171948 + 0x18) >= 0) {
+        *(s16 *)((u8 *)D_00171948 + 0x18) = -1;
+    }
+    func_00465DF8(7);
+}
diff --git a/src/game/00468C78.c b/src/game/00468C78.c
new file mode 100644
index 000000000..577c719ee
--- /dev/null
+++ b/src/game/00468C78.c
@@ -0,0 +1,46 @@
+#include "common.h"
+
+typedef struct {
+    u8 *data;
+    s32 size;
+    s32 type;
+    s32 reserved;
+} Block;
+extern void func_00453608(void *, s32, s32);
+extern void func_00453718(void *, const void *, s32);
+extern u16 func_00468BE0(const void *, s32);
+s32 func_00468C78(u8 *destination, s32 index, const Block *blocks)
+{
+    s32 size = 0;
+    u8 *out = destination + 8;
+    const Block *block;
+    s32 offset;
+    const u8 *data;
+    if (blocks->data != 0) {
+        block = blocks;
+        do {
+            size += 8;
+            offset = index * block->size;
+            data = block->data + offset;
+            *(s32 *)out = block->type;
+            *(s32 *)(out + 4) = block->size;
+            out += 8;
+            if (block->type == 0x1770) {
+                func_00453608(out, 0, block->size);
+            } else {
+                func_00453718(out, data, block->size);
+            }
+            out += block->size;
+            size += block->size;
+            block++;
+            out = (u8 *)(((s32)out + 3) & ~3);
+            size = (size + 3) & ~3;
+        } while (block->data != 0);
+    }
+    size += 8;
+    *(s32 *)(out + 4) = 0;
+    *(s32 *)out = -1;
+    *(u32 *)(destination + 4) = func_00468BE0(destination + 8, size);
+    *(s32 *)destination = size;
+    return size + 8;
+}
diff --git a/src/game/0046A9E8.c b/src/game/0046A9E8.c
new file mode 100644
index 000000000..5a4227f6e
--- /dev/null
+++ b/src/game/0046A9E8.c
@@ -0,0 +1,23 @@
+#include "common.h"
+
+typedef struct {
+    s32 field_0;
+    s32 field_4;
+    u8 field_8;
+} B2Entry;
+
+extern u8 D_001F87F0[];
+
+s32 func_0054AB08(s32 arg0, s32 arg1);
+void *func_0054A998(s32 arg0);
+s32 func_0054AC58(s32 arg0);
+
+void func_0046A9E8(s32 arg0, s32 arg1)
+{
+    if (*(s32 *)((u8 *)func_0054A998(func_0054AB08(arg0, arg1)) + 0x18) != 1) {
+        ((B2Entry *)((arg0 - 1) % 0x14 * 0x304 + arg1 * 0xC + (s32)D_001F87F0))->field_8 |= 1;
+    }
+    if ((u8)func_0054AC58(func_0054AB08(arg0, arg1)) != 0) {
+        ((B2Entry *)((arg0 - 1) % 0x14 * 0x304 + arg1 * 0xC + (s32)D_001F87F0))->field_8 |= 2;
+    }
+}
diff --git a/src/game/0046CEA0.c b/src/game/0046CEA0.c
new file mode 100644
index 000000000..248f8b8db
--- /dev/null
+++ b/src/game/0046CEA0.c
@@ -0,0 +1,69 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad[0xB];
+    u8 dimensions;
+    u8 padC[0x14];
+    u8 *data;
+} Data;
+typedef struct {
+    u8 pad[0x24];
+    Data *data;
+} Object;
+typedef struct {
+    u32 *packet;
+    u32 taggedObject;
+} Entry;
+extern Entry *D_0022144C;
+extern Entry D_00265D60[];
+extern u8 *D_00221E20;
+extern u8 D_003D82F0[], D_003DA6B0[];
+extern void func_004537D0(void *, const void *, s32);
+void func_0046CEA0(void)
+{
+    u32 *header;
+    Entry *entry;
+    if (D_0022144C == D_00265D60)
+        return;
+    header = (u32 *)D_00221E20;
+    D_00221E20 = (u8 *)(header + 4);
+    for (entry = D_00265D60; entry < D_0022144C; entry++) {
+        u32 *packet = entry->packet;
+        u32 value = entry->taggedObject;
+        Object *object;
+        Data *data;
+        s32 width, height, index;
+        u8 *base;
+        s32 i;
+        packet[0] = 0x20000000;
+        index = value & 15;
+        object = (Object *)(value & ~15);
+        packet[1] = (u32)D_00221E20;
+        packet[3] = 0x11000000;
+        data = object->data;
+        height = data->dimensions >> 4;
+        width = data->dimensions & 15;
+        base = data->data - ((width * height) << 10) - 16;
+        for (i = 0; i < height; i++) {
+            s16 value = ((s16 *)base)[i];
+            func_004537D0(D_00221E20, D_003D82F0, 0x70);
+            *(s16 *)(D_00221E20 + 0x24) = value;
+            *(u8 **)(D_00221E20 + 0x64) = base + (index << 10) + 16 + ((i * width) << 10);
+            D_00221E20 = D_00221E20 + 0x70;
+        }
+        ((u32 *)D_00221E20)[0] = 0x30000003;
+        ((u32 *)D_00221E20)[1] = (u32)D_003DA6B0;
+        ((u32 *)D_00221E20)[2] = 0;
+        ((u32 *)D_00221E20)[3] = 0x50000003;
+        D_00221E20 += 0x10;
+        ((u32 *)D_00221E20)[0] = 0x20000000;
+        ((u32 *)D_00221E20)[1] = (u32)(packet + 4);
+        ((u32 *)D_00221E20)[2] = 0;
+        ((u32 *)D_00221E20)[3] = 0;
+        D_00221E20 = D_00221E20 + 0x10;
+    }
+    header[0] = 0x20000000;
+    header[1] = (u32)D_00221E20;
+    header[2] = 0;
+    header[3] = 0;
+}
diff --git a/src/game/0046D708.c b/src/game/0046D708.c
new file mode 100644
index 000000000..ab25f2122
--- /dev/null
+++ b/src/game/0046D708.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+typedef unsigned int Quadword __attribute__((mode(TI)));
+typedef struct Cache {
+    u8 entries[0x20];
+    s32 initialized;
+} Cache;
+extern Cache D_00266A88;
+extern s32 D_001170D0[];
+extern void func_004E7450(const void *packet);
+extern char *func_0046B930(s32 classId, s32 privateBytes);
+extern void func_00470090(void *object, u32 color, u64 first, u64 second, u64 third);
+extern void func_004706F0(void *object);
+
+char *func_0046D708(s32 index, s32 classId, const Quadword *position)
+{
+    char **slot;
+    char *object;
+    func_004E7450(D_001170D0);
+    D_00266A88.initialized = 1;
+    slot = (char **)((u32)&D_00266A88 + (u32)index * 4U);
+    if (*slot != 0)
+        return *slot;
+    {
+        object = func_0046B930(classId, 0);
+        if (object != 0) {
+            *slot = object;
+            func_00470090(object, 0x202020, 14, 14, 0);
+            *(s16 *)(object + 0x32) = 0x40;
+            *(s16 *)(object + 0x34) = 0x10;
+            {
+                Quadword newPosition = *position;
+                *(u32 *)(object + 0x98) = 0;
+                *(Quadword *)(object + 0x10) = newPosition;
+            }
+            func_004706F0(object);
+        }
+    }
+    return object;
+}
diff --git a/src/game/0046E9E8.c b/src/game/0046E9E8.c
new file mode 100644
index 000000000..1379308a2
--- /dev/null
+++ b/src/game/0046E9E8.c
@@ -0,0 +1,33 @@
+#include "common.h"
+typedef struct {
+    char pad[0x10];
+    u8 frames;
+    char gap[11];
+    u8 *data;
+} Object;
+extern void func_004697C0(const void *, s32, u32), func_00469800(void), func_0046DC80(f32);
+void func_0046E9E8(Object *p, f32 frame)
+{
+    s32 i = (s32)frame, j = i + 1;
+    f32 frac = frame - i;
+    u8 *d = p->data;
+    s32 size = d[2], head = d[1];
+    u8 *first, *second;
+    if (j == p->frames)
+        j = 0;
+    i *= size;
+    j *= size;
+    first = d + (head + i) * 16;
+    second = d + (j + head) * 16;
+    if (head) {
+        func_004697C0(d, head, 0x2000);
+        func_00469800();
+    }
+    if (size) {
+        func_004697C0(first, size, 0x3000);
+        func_00469800();
+        func_004697C0(second, size, 0x3800);
+        func_00469800();
+    }
+    func_0046DC80(frac);
+}
diff --git a/src/game/0047ED10.c b/src/game/0047ED10.c
new file mode 100644
index 000000000..24a8126f5
--- /dev/null
+++ b/src/game/0047ED10.c
@@ -0,0 +1,19 @@
+#include "common.h"
+
+extern s32 D_0021DDB8;
+extern s32 func_00453C68(s32, s32, f32);
+
+s32 func_0047ED10(s32 alpha)
+{
+    f32 value = (f32)(D_0021DDB8 % 150) / 150.0f;
+    s32 color;
+    if (value < 0.333f) {
+        color = func_00453C68(0x00804020, 0x00208040, value * 3.0f);
+    } else if (value < 0.667f) {
+        color = func_00453C68(0x00208040, 0x00402080, (value - 0.333f) * 3.0f);
+    } else {
+        color = func_00453C68(0x00402080, 0x00804020, (value - 0.667f) * 3.0f);
+    }
+    color &= 0x00FFFFFF;
+    return color | (alpha << 24);
+}
diff --git a/src/game/00481100.c b/src/game/00481100.c
new file mode 100644
index 000000000..c6403c645
--- /dev/null
+++ b/src/game/00481100.c
@@ -0,0 +1,67 @@
+#include "common.h"
+
+typedef void (*Callback)(void *, s32);
+extern void *func_004765F0(void *);
+
+typedef struct Descriptor {
+    u8 unknown0[5];
+    u8 inherit;
+    u8 unknown6[2];
+    u32 flags;
+} Descriptor;
+
+static inline Descriptor *getDescriptor(void *object)
+{
+    u32 address = (u32)object;
+    u32 index = *(u8 *)(address + 0x54);
+    u32 table = *(u32 *)(address + 0x24);
+    u32 asset = *(u32 *)(table + (index << 2) + 0x48);
+    u32 metadata = *(u32 *)(asset + 0x18);
+    return *(Descriptor **)(metadata + 4);
+}
+
+s32 func_00481100(void *object, s32 mode, s32 temporary)
+{
+    u32 stateAddress;
+    Callback callback;
+    Descriptor *descriptor;
+    u32 value;
+
+    stateAddress = (u32)func_004765F0(object);
+    if (stateAddress == 0) {
+        return 0;
+    }
+    if (*(u8 *)(stateAddress + 0x33) != mode) {
+        return 1;
+    }
+    if (mode <= 0) {
+        return 1;
+    }
+    *(s32 *)(stateAddress + 0x4) &= -0x81;
+    *(s32 *)(stateAddress + 0x4) &= 0xFFFDFFFF;
+    *(s32 *)(stateAddress + 0x4) &= -0x1001;
+    callback = *(Callback *)(stateAddress + 0x6C);
+    *(s32 *)(stateAddress + 0xC) = 1;
+    *(u8 *)(stateAddress + 0x33) = 0;
+    *(Callback *)(stateAddress + 0x6C) = 0;
+    descriptor = getDescriptor(object);
+    if (descriptor->inherit == 0 || *(void **)(stateAddress + 0x5C) == 0) {
+        value = descriptor->flags;
+    } else {
+        descriptor = getDescriptor(*(void **)(stateAddress + 0x5C));
+        value = descriptor->flags;
+    }
+    if ((value & 2) != 0) {
+        *(s32 *)(stateAddress + 0x4) |= 0x800;
+    }
+    if (temporary != 0) {
+        *(s32 *)(stateAddress + 0x4) |= 0x80;
+    }
+    if (callback != 0) {
+        callback(object, 4);
+    }
+    if (temporary != 0) {
+        *(s32 *)(stateAddress + 0x4) &= -0x81;
+    }
+    return 1;
+}
diff --git a/src/game/00484F68.c b/src/game/00484F68.c
new file mode 100644
index 000000000..29d5b9edf
--- /dev/null
+++ b/src/game/00484F68.c
@@ -0,0 +1,96 @@
+#include "common.h"
+
+typedef struct {
+    char pad0[5];
+    u8 state;
+    char pad6[2];
+    u32 flags;
+    char padC[8];
+    f32 duration;
+} Animation;
+
+typedef struct Object Object;
+struct Object {
+    char pad0[4];
+    u32 flags;
+    char pad8[4];
+    s32 mismatch;
+    char pad10[0x14];
+    char *entries;
+    char pad28[0xB];
+    u8 state;
+    char pad34[0x20];
+    u8 index;
+    u8 finalFlags;
+    char pad56[6];
+    Object *linked;
+    char pad60[0xC];
+    s32 (*callback)(Object *, s32);
+};
+
+extern s32 func_004845B8(Object *, f32);
+extern void func_00481100(Object *, u8, s32);
+
+static inline Animation *get_animation(Object *obj)
+{
+    char *base;
+    char *entry;
+    char *table;
+    s32 offset;
+
+    base = obj->entries;
+    offset = obj->index * 4;
+    entry = *(char **)(base + offset + 0x48);
+    table = *(char **)(entry + 0x18);
+    return *(Animation **)(table + 4);
+}
+
+void func_00484F68(Object *arg0, Object *arg1)
+{
+    Animation *animation = get_animation(arg0);
+    Object *current = arg0;
+    Object *linked;
+    s32 (*callback)(Object *, s32);
+    u8 state = arg1->state;
+
+    if (animation->state != state) {
+        if (arg1->linked != NULL) {
+            animation = get_animation(arg1->linked);
+            current = arg1->linked;
+        }
+    }
+    if (animation->state == state) {
+        if ((animation->flags & 2) != 0 || (arg1->flags & 0x20000) != 0) {
+            if (arg1->callback != NULL) {
+                arg1->callback(arg0, 1);
+            }
+        }
+        if ((arg1->flags & 0x40000) == 0 && arg1->callback != NULL) {
+            if (animation->duration > 0.0f && func_004845B8(current, animation->duration) != 0) {
+                callback = arg1->callback;
+                callback(arg0, 2);
+                arg1->flags |= 0x40000;
+            }
+            if (current == arg0 && (linked = arg1->linked) != NULL) {
+                Animation *linkedAnimation = get_animation(linked);
+                if (linkedAnimation->state == arg1->state && linkedAnimation->duration > 0.0f &&
+                    func_004845B8(linked, linkedAnimation->duration) != 0) {
+                    arg1->callback(arg0, 2);
+                    arg1->flags |= 0x40000;
+                }
+            }
+        }
+        if ((current->finalFlags & 2) != 0) {
+            if ((animation->flags & 4) != 0) {
+                if (arg1->callback != NULL) {
+                    arg1->callback(arg0, 3);
+                }
+                arg1->flags &= ~0x40000;
+            } else {
+                func_00481100(arg0, arg1->state, 0);
+            }
+        }
+    } else {
+        arg1->mismatch = 1;
+    }
+}
diff --git a/src/game/0048B840.c b/src/game/0048B840.c
new file mode 100644
index 000000000..1acb30a1f
--- /dev/null
+++ b/src/game/0048B840.c
@@ -0,0 +1,36 @@
+#include "common.h"
+
+extern s32 D_002214D8;
+
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+
+s32 func_0048B840(const u8 *arg0, u8 **arg1, const u8 *arg2) {
+    s32 i;
+    s32 offset;
+
+    func_00453718((void *)(D_002214D8 + 0x300C), arg0, 4);
+    arg0 += 4;
+    *(void **)(D_002214D8 + 0x3010) = func_0048B818(*(s32 *)(D_002214D8 + 0x300C) * 0xC, arg1, arg2);
+    if (*(s32 *)(D_002214D8 + 0x3010) == 0) {
+        return 1;
+    }
+    if (*(s32 *)(D_002214D8 + 0x300C) <= 0) {
+        return 0;
+    }
+    i = 0;
+    offset = 0;
+    do {
+        if (*(s32 *)(D_002214D8 + 0x3000) >= 2) {
+            func_00453718((void *)(*(u32 *)(D_002214D8 + 0x3010) + offset), arg0, 0xC);
+            arg0 += 0xC;
+        } else {
+            func_00453718((void *)(*(u32 *)(D_002214D8 + 0x3010) + offset), arg0, 8);
+            arg0 += 8;
+            *(s16 *)(offset + *(s32 *)(D_002214D8 + 0x3010) + 8) = 0;
+        }
+        i++;
+        offset += 0xC;
+    } while (i < *(s32 *)(D_002214D8 + 0x300C));
+    return 0;
+}
diff --git a/src/game/0048BB38.c b/src/game/0048BB38.c
new file mode 100644
index 000000000..d3fab5652
--- /dev/null
+++ b/src/game/0048BB38.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_002214D8;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_002214D8 + 0x3024);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_002214D8 + 0x3028);
+}
+s32 func_0048BB38(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_002214D8 + 0x3024, input, 4);
+    input += 4;
+    *(u32 *)(D_002214D8 + 0x3028) = (u32)func_0048B818((u32)count() << 3, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i << 3), input, 8);
+        input += 8;
+    }
+    return 0;
+}
diff --git a/src/game/0048BC20.c b/src/game/0048BC20.c
new file mode 100644
index 000000000..6435d23c0
--- /dev/null
+++ b/src/game/0048BC20.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_002214D8;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_002214D8 + 0x303C);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_002214D8 + 0x3040);
+}
+s32 func_0048BC20(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_002214D8 + 0x303C, input, 4);
+    input += 4;
+    *(u32 *)(D_002214D8 + 0x3040) = (u32)func_0048B818((u32)count() * 12u, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i * 12u), input, 12);
+        input += 12;
+    }
+    return 0;
+}
diff --git a/src/game/0048BD08.c b/src/game/0048BD08.c
new file mode 100644
index 000000000..47217dc23
--- /dev/null
+++ b/src/game/0048BD08.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_002214D8;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_002214D8 + 0x3044);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_002214D8 + 0x3048);
+}
+s32 func_0048BD08(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_002214D8 + 0x3044, input, 4);
+    input += 4;
+    *(u32 *)(D_002214D8 + 0x3048) = (u32)func_0048B818((u32)count() << 3, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i << 3), input, 8);
+        input += 8;
+    }
+    return 0;
+}
diff --git a/src/game/0048BF90.c b/src/game/0048BF90.c
new file mode 100644
index 000000000..18f625c5e
--- /dev/null
+++ b/src/game/0048BF90.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_002214D8;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_002214D8 + 0x305C);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_002214D8 + 0x3060);
+}
+s32 func_0048BF90(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_002214D8 + 0x305C, input, 4);
+    input += 4;
+    *(u32 *)(D_002214D8 + 0x3060) = (u32)func_0048B818((u32)count() * 4u, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i * 4u), input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/game/0048C078.c b/src/game/0048C078.c
new file mode 100644
index 000000000..5d7c8dc05
--- /dev/null
+++ b/src/game/0048C078.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_002214D8;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_002214D8 + 0x3064);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_002214D8 + 0x3068);
+}
+s32 func_0048C078(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_002214D8 + 0x3064, input, 4);
+    input += 4;
+    *(u32 *)(D_002214D8 + 0x3068) = (u32)func_0048B818((u32)count() * 4u, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i * 4u), input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/game/0048C160.c b/src/game/0048C160.c
new file mode 100644
index 000000000..9ef9eacbb
--- /dev/null
+++ b/src/game/0048C160.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_002214D8;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_002214D8 + 0x306C);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_002214D8 + 0x3070);
+}
+s32 func_0048C160(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_002214D8 + 0x306C, input, 4);
+    input += 4;
+    *(u32 *)(D_002214D8 + 0x3070) = (u32)func_0048B818((u32)count() * 4u, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i * 4u), input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/game/0048C248.c b/src/game/0048C248.c
new file mode 100644
index 000000000..74f503b34
--- /dev/null
+++ b/src/game/0048C248.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_002214D8;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_002214D8 + 0x3074);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_002214D8 + 0x3078);
+}
+s32 func_0048C248(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_002214D8 + 0x3074, input, 4);
+    input += 4;
+    *(u32 *)(D_002214D8 + 0x3078) = (u32)func_0048B818((u32)count() * 4u, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i * 4u), input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/game/0048C330.c b/src/game/0048C330.c
new file mode 100644
index 000000000..a25d41bc9
--- /dev/null
+++ b/src/game/0048C330.c
@@ -0,0 +1,24 @@
+#include "common.h"
+
+extern u8 *D_002214D8;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+s32 func_0048C330(const u8 *source, u8 **cursor, const u8 *limit)
+{
+    s32 i;
+    if (*(s32 *)(D_002214D8 + 0x3000) < 2) {
+        *(u8 **)(D_002214D8 + 0x3038) = 0;
+        *(s32 *)(D_002214D8 + 0x3034) = 0;
+        return 0;
+    }
+    func_00453718(D_002214D8 + 0x3034, source, 4);
+    source += 4;
+    *(u8 **)(D_002214D8 + 0x3038) = func_0048B818((u32) * (s32 *)(D_002214D8 + 0x3034) << 2, cursor, limit);
+    if (!*(u8 **)(D_002214D8 + 0x3038))
+        return 1;
+    for (i = 0; i < *(s32 *)(D_002214D8 + 0x3034); i++) {
+        func_00453718(*(u8 **)(D_002214D8 + 0x3038) + i * 4, source, 4);
+        source += 4;
+    }
+    return 0;
+}
diff --git a/src/game/0048C440.c b/src/game/0048C440.c
new file mode 100644
index 000000000..b296edf0d
--- /dev/null
+++ b/src/game/0048C440.c
@@ -0,0 +1,41 @@
+#include "common.h"
+extern u32 *D_002214D8;
+extern void *func_0048B818(u32, u8 **, const u8 *);
+extern void func_00453718(void *, const void *, u32);
+s32 func_0048C440(const u8 *input, u8 **cursor, const u8 *limit)
+{
+    u32 *state = D_002214D8;
+    void *result;
+    s32 count;
+    u32 offset;
+    if ((s32)state[0xC00] < 2) {
+        result = func_0048B818(12, cursor, limit);
+        D_002214D8[0xC0C] = (u32)result;
+        if (!D_002214D8[0xC0C])
+            return 1;
+        D_002214D8[0xC0B] = 1;
+        *(u16 *)D_002214D8[0xC0C] = 0;
+        *(u16 *)(D_002214D8[0xC0C] + 2) = *(u16 *)((u8 *)D_002214D8 + 0x300C);
+        *(u16 *)(D_002214D8[0xC0C] + 4) = 0;
+        *(u16 *)(D_002214D8[0xC0C] + 6) = 0;
+        *(u16 *)(D_002214D8[0xC0C] + 8) = 0;
+        return 0;
+    }
+    func_00453718(&state[0xC0B], input, 4);
+    input += 4;
+    result = func_0048B818(D_002214D8[0xC0B] * 12, cursor, limit);
+    D_002214D8[0xC0C] = (u32)result;
+    if (!D_002214D8[0xC0C])
+        return 1;
+    count = 0;
+    if (count >= (s32)D_002214D8[0xC0B])
+        return 0;
+    offset = 0;
+    do {
+        func_00453718((void *)(D_002214D8[0xC0C] + offset), input, 12);
+        input += 12;
+        offset += 12;
+        ++count;
+    } while (count < (s32)D_002214D8[0xC0B]);
+    return 0;
+}
diff --git a/src/game/0048D228.c b/src/game/0048D228.c
new file mode 100644
index 000000000..ba9ef7aa8
--- /dev/null
+++ b/src/game/0048D228.c
@@ -0,0 +1,59 @@
+#include "common.h"
+
+typedef struct {
+    u16 first, count, offset;
+    u8 rest[6];
+} Grid;
+typedef struct {
+    u16 first;
+    s16 count;
+} Cell;
+typedef struct {
+    u16 first, second, cost, flags;
+} Entry;
+typedef struct {
+    u8 p0[0x3008];
+    Cell *cells;
+    u8 p300C[4];
+    Grid *grids;
+    u8 p3014[4];
+    u8 *objects;
+    u8 p301C[0x2C];
+    Entry *entries;
+} Manager;
+extern Manager *D_002214D8;
+void func_0048D228(s32 first, s32 second, s32 mask, u16 *out_first, u16 *out_second, s32 *cost)
+{
+    Manager *manager;
+    Grid *grid;
+    typedef struct {
+        u8 p0[8];
+        u16 grid;
+        u8 pA[22];
+    } Object;
+    Object *object;
+    Cell *cell;
+    Entry *entry;
+    u32 end;
+    u32 index;
+    *out_first = 0xFFFF;
+    *out_second = 0xFFFF;
+    *cost = 0xFFFFFF;
+    first &= 0xFFFF;
+    manager = D_002214D8;
+    second &= 0xFFFF;
+    object = (Object *)((u32)manager->objects + (u32)first * 32);
+    grid = (Grid *)((u32)object->grid * 12 + (u32)manager->grids);
+    index = grid->offset + (first - grid->first) * grid->count + (second - grid->first);
+    cell = (Cell *)((u32)manager->cells + index * 4);
+    entry = (Entry *)((u32)manager->entries + (u32)cell->first * 8);
+    end = (u32)entry + (u32)cell->count * 8;
+    while ((u32)entry < end) {
+        if ((s32)entry->cost < *cost && entry->first != 0xFFFF && (entry->flags & mask) == entry->flags) {
+            *out_first = entry->first;
+            *out_second = entry->second;
+            *cost = entry->cost;
+        }
+        entry = (Entry *)((u32)entry + 8);
+    }
+}
diff --git a/src/game/00498270.c b/src/game/00498270.c
new file mode 100644
index 000000000..a66d7e0e0
--- /dev/null
+++ b/src/game/00498270.c
@@ -0,0 +1,41 @@
+#include "common.h"
+typedef struct {
+    u8 gap[6];
+    s16 primary, secondary;
+} Descriptor;
+typedef struct {
+    u8 gap[0x26E4];
+    void *inventory;
+} Hero;
+typedef struct {
+    char text[64];
+} Buffer;
+extern Buffer D_002F31B8[];
+extern const char D_0021F590[];
+extern Descriptor *func_00548D28(s32, s32);
+extern const char *func_0045E038(s32);
+extern Hero *func_00510BE8(s32);
+extern s32 func_00547D58(void *, s32), func_0011D920(char *, const char *, ...);
+const char *func_00498270(s32 index, s32 item, s32 numbered, s32 primary, s32 minimum)
+{
+    const char *result = (D_002F31B8 + index)->text;
+    const char *text;
+    Hero *hero;
+    s32 level;
+    if (primary)
+        text = func_0045E038(func_00548D28(item, 0)->primary);
+    else
+        text = func_0045E038(func_00548D28(item, 0)->secondary);
+    hero = func_00510BE8(index);
+    level = 0;
+    if (hero && hero->inventory)
+        level = func_00547D58(hero->inventory, item);
+    if (level >= minimum) {
+        if (numbered)
+            func_0011D920((char *)result, D_0021F590, text, level + 1);
+        else
+            result = text;
+    } else
+        result = text;
+    return result;
+}
diff --git a/src/game/00498A98.c b/src/game/00498A98.c
new file mode 100644
index 000000000..bfe629467
--- /dev/null
+++ b/src/game/00498A98.c
@@ -0,0 +1,37 @@
+#include "common.h"
+
+extern s32 D_0021EDD4;
+extern void *func_00510BE8(s32);
+extern void *func_00548D28(s32, s32);
+extern s32 func_00547D58(void *, s32);
+extern s32 func_00498918(s32, s32);
+extern f32 func_00475710(f32, f32, f32);
+extern s32 func_00453C68(s32, s32, f32);
+
+s32 func_00498A98(s32 a0, s32 a1)
+{
+    void *object;
+    s32 value;
+    s32 color;
+
+    if (D_0021EDD4 != 1) {
+        a0 = 0;
+    }
+    object = func_00510BE8(a0);
+    if (*(u8 *)((u8 *)func_00548D28(a1, 0) + 0x28) != 0) {
+        value = func_00547D58(*(void **)((u8 *)object + 0x26E4), a1);
+        if (D_0021EDD4 == 1 ? value > 0 : value >= 10) {
+            s32 second;
+            f32 blend;
+            color = func_00498918(0, 0);
+            if (D_0021EDD4 != 1) {
+                second = func_00498918(5, 0);
+                blend = func_00475710((f32)value, 10.0f, 98.0f);
+                color = func_00453C68(color, second, blend);
+            }
+        } else
+            color = 0x80D0D0D0;
+    } else
+        color = func_00498918(4, 3);
+    return color;
+}
diff --git a/src/game/004993D8.c b/src/game/004993D8.c
new file mode 100644
index 000000000..2071149fc
--- /dev/null
+++ b/src/game/004993D8.c
@@ -0,0 +1,43 @@
+#include "common.h"
+typedef struct Block Block;
+typedef struct Object Object;
+typedef struct Spec {
+    s32 id;
+    u32 sectors;
+} Spec;
+typedef struct Entry {
+    Block *block;
+    Object *object;
+    s32 references, unknown;
+    Spec *spec;
+} Entry;
+extern Entry D_002F3950[];
+extern Block *func_00499320(u32, s32);
+extern s32 func_004A2D90(Object *, void *, s32);
+extern void func_00499538(Entry *);
+Entry *func_004993D8(Spec *spec, s32 value)
+{
+    Entry *empty = 0;
+    s32 i;
+    for (i = 0; i < 32; i++) {
+        if (D_002F3950[i].spec == spec) {
+            D_002F3950[i].references++;
+            return &D_002F3950[i];
+        }
+        if (!D_002F3950[i].references && !empty)
+            empty = &D_002F3950[i];
+    }
+    if (empty) {
+        Block *b = func_00499320(spec->sectors << 11, 1);
+        if (b) {
+            empty->references++;
+            empty->unknown = value;
+            empty->spec = spec;
+            func_004A2D90(empty->object, 0, 0);
+            empty->block = b;
+            func_00499538(empty);
+        } else
+            empty = 0;
+    }
+    return empty;
+}
diff --git a/src/game/0049B960.c b/src/game/0049B960.c
new file mode 100644
index 000000000..b7848db4e
--- /dev/null
+++ b/src/game/0049B960.c
@@ -0,0 +1,48 @@
+#include "common.h"
+
+typedef struct Entry {
+    f32 value;
+    u8 unknown4[0x20];
+    u8 target;
+    u8 unknown25[3];
+    f32 visibility;
+    u8 secondaryTarget;
+    u8 unknown2D[3];
+    f32 secondary;
+} Entry;
+
+extern u8 D_00306F2C[];
+extern u8 D_003070D8[];
+extern s32 func_00505B20(void);
+extern f32 func_0049B528(f32 *value, s32 target);
+extern void func_0049BAB0(s32 context, s32 entry);
+
+void func_0049B960(void)
+{
+    s32 i = 0;
+    u32 offset = 0;
+    s32 index = func_00505B20();
+    u32 contextOffset = (u32)index << 9;
+    Entry *standard = (Entry *)D_003070D8;
+
+    for (; i < 4; i++, standard++, offset += 0x34) {
+        Entry *p = (Entry *)(contextOffset + (u32)standard);
+        u8 first;
+        s32 second;
+        s32 third;
+
+        if (index == 4) {
+            p = (Entry *)((u32)D_00306F2C + offset);
+        }
+        if (p->visibility == 0.0f && p->target == 0) {
+            continue;
+        }
+        first = func_0049B528(&p->value, 1) != 0.0f;
+        second = func_0049B528(&p->visibility, p->target) != 0.0f;
+        first = (second | first) != 0;
+        third = func_0049B528(&p->secondary, p->secondaryTarget) != 0.0f;
+        if (third | first) {
+            func_0049BAB0(index, i);
+        }
+    }
+}
diff --git a/src/game/0049E140.c b/src/game/0049E140.c
new file mode 100644
index 000000000..2e3fceab4
--- /dev/null
+++ b/src/game/0049E140.c
@@ -0,0 +1,47 @@
+#include "common.h"
+
+extern s32 D_00307074[];
+extern s32 D_00307220[];
+extern s32 *D_0021DDA4;
+extern s32 D_0021EDD4;
+extern s32 D_0021EDD8;
+extern s32 func_00505B20(void);
+extern s32 *func_00510BE8(s32);
+extern f32 func_0049B528(void *, s32);
+extern void func_0049E2B8(s32);
+extern void func_0049E478(s32);
+extern void func_00497438(s32, s32, s32);
+
+void func_0049E140(void) {
+    s32 index = func_00505B20();
+    s32 *record;
+    s32 *state;
+
+    if (index == 4) {
+        record = D_00307074;
+    } else {
+        record = D_00307220 + index * 0x80;
+    }
+    state = func_00510BE8(index);
+    if (func_0049B528(record + 1, ((u8 *)record)[0]) == 0.0f) {
+        if (((u8 *)record)[0] != 0 && ((u8 *)record)[0x1C] == 0) {
+            func_0049E2B8(index);
+        }
+    } else {
+        func_0049E478(index);
+    }
+    if (*(f32 *)(record + 1) == 0.0f) {
+        return;
+    }
+    if (index == 4) {
+        for (index = 0; index < *D_0021DDA4; index++) {
+            func_00497438(index, 3, 4);
+        }
+        return;
+    }
+    *(s16 *)((u8 *)state + 0x3BA) = 3;
+    func_00497438(index, 3, 4);
+    if (D_0021EDD4 == 0 && D_0021EDD8 == 1) {
+        func_00497438((u32)index < 1, 3, 4);
+    }
+}
diff --git a/src/game/0049F4F8.c b/src/game/0049F4F8.c
new file mode 100644
index 000000000..124811f31
--- /dev/null
+++ b/src/game/0049F4F8.c
@@ -0,0 +1,50 @@
+#include "common.h"
+
+extern s32 D_00307254[];
+extern s32 func_00505B20(void);
+extern s32 func_004A0208(s32);
+extern s32 func_0049F9F0(s32);
+extern void func_0049FB78(s32);
+extern void func_0049F928(s32);
+extern f32 func_004973E0(void *, s32);
+extern void func_0049FBF0(s32);
+extern void func_00499CE0(s32);
+extern void func_005054F8(s32, s32);
+
+void func_0049F4F8(void) {
+    s32 index = func_00505B20();
+    s32 *record = D_00307254 + index * 0x80;
+    f32 value;
+    f32 zero;
+    s32 first;
+    s32 second;
+
+    if (((u8 *)record)[0x24] != 0) {
+        if (*(f32 *)(record + 0xA) == 1.0f && record[0xC] == record[0xD]) {
+            if (func_0049F9F0(func_004A0208(index)) == 0) {
+                func_0049FB78(1);
+            }
+            func_0049F928(index);
+            return;
+        }
+    }
+    value = *(f32 *)(record + 0xA);
+
+fallback:
+    zero = 0.0f;
+    if (value != zero || ((u8 *)record)[0x24] != 0) {
+        first = func_004973E0(record + 0xA, ((u8 *)record)[0x24]) != zero;
+        second = func_004973E0(record + 0xE, 0) != zero;
+        if ((second | first) != 0) {
+            func_0049FBF0(index);
+        }
+        return;
+    }
+
+    if (record[0x14] == 0) {
+        return;
+    }
+    func_00499CE0(record[0x14]);
+    record[0x14] = 0;
+    func_005054F8(index * 0x40 + 0x140004, 0);
+}
diff --git a/src/game/0049F660.c b/src/game/0049F660.c
new file mode 100644
index 000000000..99377c92a
--- /dev/null
+++ b/src/game/0049F660.c
@@ -0,0 +1,27 @@
+#include "common.h"
+typedef struct {
+    char pad[0x14];
+    f32 x, y, w, h;
+    u8 active;
+    char gap[7];
+    s32 choice;
+    char rest[0x1D0];
+} State;
+extern State D_00307254[];
+extern void func_0049FBF0(s32), func_0049F758(s32, f32 *, f32 *, f32 *, f32 *), func_0049F828(s32, s32, f32 *, f32 *, f32 *, f32 *), func_0049CFE8(s32, s32, f32, f32, f32, f32), func_0049BFC0(s32, s32, s32, f32, f32, f32, f32);
+void func_0049F660(s32 index, f32 x, f32 y, f32 w, f32 h)
+{
+    f32 c, d;
+    State *p = D_00307254 + index;
+    p->x = x;
+    p->y = y;
+    p->w = w;
+    p->h = h;
+    if (p->active) {
+        func_0049FBF0(index);
+        func_0049F758(index, &x, &y, &c, &d);
+        func_0049CFE8(index, 0, x, y, c, d);
+        func_0049F828(index, p->choice, &x, &y, &c, &d);
+        func_0049BFC0(index, 0, 0, x, y, c, d);
+    }
+}
diff --git a/src/game/0049F758.c b/src/game/0049F758.c
new file mode 100644
index 000000000..c2861c838
--- /dev/null
+++ b/src/game/0049F758.c
@@ -0,0 +1,28 @@
+#include "common.h"
+
+typedef struct {
+    u8 prefix[0x14];
+    f32 x, y, width, factor;
+    u8 gap[0xC];
+    s32 frame;
+    u8 gap34[0x10];
+    u8 active;
+    u8 tail[0x1BB];
+} State;
+extern State D_00307254[];
+void func_0049F758(s32 index, f32 *x, f32 *y, f32 *width, f32 *height)
+{
+    f32 intermediate, spacing;
+    State *state = &D_00307254[index];
+    if (state->active)
+        spacing = state->width * 0.48582998f;
+    else
+        spacing = 0.024038462f;
+    intermediate = state->factor * (f32)state->frame;
+    *height = intermediate;
+    *height = intermediate + (f32)(state->frame + 1) * 0.0072115385f +
+              (spacing + 0.024038462f) + 0.009615385f;
+    *x = state->x;
+    *y = state->y;
+    *width = state->width + 0.0078125f;
+}
diff --git a/src/game/0049F828.c b/src/game/0049F828.c
new file mode 100644
index 000000000..c68e8456d
--- /dev/null
+++ b/src/game/0049F828.c
@@ -0,0 +1,37 @@
+#include "common.h"
+
+typedef struct {
+    u8 prefix[0x14];
+    f32 x, y, width, factor;
+    u8 gap[0xC];
+    s32 frame;
+    u8 gap34[0x10];
+    u8 active;
+    u8 tail[0x1BB];
+} State;
+extern State D_00307254[];
+void func_0049F828(s32 index, s32 row, f32 *x, f32 *y, f32 *width, f32 *height)
+{
+    State *state = &D_00307254[index];
+    f32 spacing;
+    f32 value;
+
+    f32 a, b, c;
+    s32 frame;
+    if (state->active)
+        spacing = state->width * 0.48582998f;
+    else
+        spacing = 0.024038462f;
+    frame = state->frame;
+    a = state->factor * (f32)frame;
+    b = (f32)(frame + 1) * 0.0072115385f;
+    c = spacing + 0.024038462f;
+    *width = state->width;
+    *height = state->factor;
+    *x = state->x;
+    value = (state->y - ((a + b + c) * 0.5f)) + (spacing + 0.0072115385f);
+    *y = value;
+    value = value + *height * 0.5f;
+    *y = value;
+    *y = value + (*height + 0.0072115385f) * (f32)row;
+}
diff --git a/src/game/004A06F8.c b/src/game/004A06F8.c
new file mode 100644
index 000000000..0653b27e5
--- /dev/null
+++ b/src/game/004A06F8.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Allocator *func_005011A8(Manager *, s32);
+extern void func_00504228(s32);
+extern s32 func_00504230(void);
+extern s32 func_004FF910(void *, u32);
+extern void *func_0015DB80(u32, void *);
+extern Object *func_0050D2E8(void *);
+extern s32 func_005005A8(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00222038;
+    if (manager->table) {
+        return manager;
+    }
+    return func_005010E0();
+}
+
+s32 func_004A06F8(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_00504228(0x48);
+    size = func_00504230();
+    if (entry != NULL && func_004FF910(entry, key) == 0) {
+        allocator = func_005011A8(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_0050D2E8(func_0015DB80(0x48, block));
+            result = func_005005A8(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_005011A8(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/game/004A0870.c b/src/game/004A0870.c
new file mode 100644
index 000000000..a53a5c859
--- /dev/null
+++ b/src/game/004A0870.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Allocator *func_005011A8(Manager *, s32);
+extern void func_00504228(s32);
+extern s32 func_00504230(void);
+extern s32 func_004FF910(void *, u32);
+extern void *func_0015DB80(u32, void *);
+extern Object *func_0050EB00(void *);
+extern s32 func_005005A8(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00222038;
+    if (manager->table) {
+        return manager;
+    }
+    return func_005010E0();
+}
+
+s32 func_004A0870(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_00504228(0x50);
+    size = func_00504230();
+    if (entry != NULL && func_004FF910(entry, key) == 0) {
+        allocator = func_005011A8(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_0050EB00(func_0015DB80(0x50, block));
+            result = func_005005A8(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_005011A8(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/game/004A09E8.c b/src/game/004A09E8.c
new file mode 100644
index 000000000..8b416085e
--- /dev/null
+++ b/src/game/004A09E8.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Allocator *func_005011A8(Manager *, s32);
+extern void func_00504228(s32);
+extern s32 func_00504230(void);
+extern s32 func_004FF910(void *, u32);
+extern void *func_0015DB80(u32, void *);
+extern Object *func_0050E360(void *);
+extern s32 func_005005A8(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00222038;
+    if (manager->table) {
+        return manager;
+    }
+    return func_005010E0();
+}
+
+s32 func_004A09E8(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_00504228(0x70);
+    size = func_00504230();
+    if (entry != NULL && func_004FF910(entry, key) == 0) {
+        allocator = func_005011A8(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_0050E360(func_0015DB80(0x70, block));
+            result = func_005005A8(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_005011A8(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/game/004A1240.c b/src/game/004A1240.c
new file mode 100644
index 000000000..01336c81c
--- /dev/null
+++ b/src/game/004A1240.c
@@ -0,0 +1,47 @@
+#include "common.h"
+
+typedef struct {
+    u8 unknown0[12];
+    u8 dirty;
+    u8 unknownD[11];
+} Row;
+
+typedef s32 (*Validator)(s32);
+
+typedef struct {
+    u8 unknown0[0x34];
+    Row *rows;
+    u8 unknown38[12];
+    Validator validate;
+    u8 unknown48[8];
+    s32 count;
+    s32 selected;
+    u32 flags;
+} List;
+
+extern void func_004A1310(List *);
+
+void func_004A1240(List *list, s32 index)
+{
+    s32 maximum;
+
+    if (list->count != 0) {
+        maximum = list->count - 1;
+        index = index > maximum ? maximum : index;
+        index = index < 0 ? 0 : index;
+        if (index != list->selected) {
+            if (list->selected >= 0) {
+                list->rows[list->selected].dirty = 1;
+            }
+            list->selected = index;
+            if (index >= 0) {
+                list->rows[index].dirty = 1;
+            }
+            list->flags |= 2;
+        }
+        if (list->selected >= 0 && list->validate != 0 &&
+            list->validate(list->selected) == 0) {
+            func_004A1310(list);
+        }
+    }
+}
diff --git a/src/game/004A1B48.c b/src/game/004A1B48.c
new file mode 100644
index 000000000..d532d26e6
--- /dev/null
+++ b/src/game/004A1B48.c
@@ -0,0 +1,70 @@
+#include "common.h"
+
+extern void func_0049EF30(s32);
+s32 D_0021F658 = 1;
+
+extern void func_004A1D58(s32 active);
+
+typedef struct GameInfo {
+    u8 pad00[8];
+    s32 mode;
+    s32 value;
+    s32 unknown10;
+    s32 ready;
+    s16 code;
+    u8 pad1A[0x1AA];
+    s32 connection;
+    s32 unknown1C8;
+    s32 error;
+} GameInfo;
+extern u8 D_00171948[];
+extern const char *func_0045E080(s32 label);
+extern void func_0049E790(s32 mode, const char *text, void (*callback)(s32),
+                          s32 buttons, s32 f4, s32 f5, s32 f6, f32 timeout);
+extern void func_0049B148(s32 context, s32 mask);
+extern void func_005014B0(s32 *group);
+
+void func_004A1B48(s32 *group)
+{
+    switch (D_0021F658) {
+    case 1: {
+        GameInfo *game = (GameInfo *)D_00171948;
+        if (game->connection == 2 && game->error < 0) {
+            if (game->mode != 2) {
+                func_0049E790(0, func_0045E080(0x19B), func_004A1D58,
+                              3, 0, 0, 0, -1.0f);
+                D_0021F658 = 2;
+            } else if (game->ready != 0 && game->code < -1 && game->value < 400) {
+                func_0049E790(0, func_0045E080(0x198), func_004A1D58,
+                              3, 0, 0, 0, -1.0f);
+                D_0021F658 = 3;
+            } else {
+                D_0021F658 = 4;
+            }
+        }
+        break;
+    }
+    case 2: {
+        GameInfo *game = (GameInfo *)D_00171948;
+        if (game->connection == 2 && game->error < 0 && game->mode == 2) {
+            func_0049EF30(0);
+            D_0021F658 = 1;
+        }
+        break;
+    }
+    case 3: {
+        GameInfo *game = (GameInfo *)D_00171948;
+        if (game->connection == 2 && game->error < 0 && game->mode != game->connection) {
+            func_0049EF30(0);
+            func_0049E790(0, func_0045E080(0x19B), func_004A1D58,
+                          3, 0, 0, 0, -1.0f);
+            D_0021F658 = 1;
+        }
+        break;
+    }
+    case 4:
+        func_0049B148(0, 0x20);
+        func_005014B0(group);
+        break;
+    }
+}
diff --git a/src/game/004A2B18.c b/src/game/004A2B18.c
new file mode 100644
index 000000000..b7723b58a
--- /dev/null
+++ b/src/game/004A2B18.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+typedef struct {
+    s32 offset, size;
+} Entry;
+typedef struct {
+    s32 state;
+    u8 p4[8];
+    void *buffer;
+    u8 p10[4];
+    Entry *table;
+    s32 base, selected;
+} Transfer;
+extern s32 func_00163928(void);
+extern void func_001634A8(s32);
+typedef void (*Completion)(s32, s32);
+extern s32 func_00163840(s32, void *, s32, s32, const void *, Completion, s32);
+s32 func_004A2B18(Transfer *transfer, s32 selected)
+{
+    s32 result = 0;
+    if (transfer->table && transfer->buffer && (transfer->state ^ 4) != 0 && (transfer->state ^ 8) != 0) {
+        if (func_00163928() == 0) {
+            s32 size = *(s32 *)((u32)selected * 8 + (u32)transfer->table + 4);
+            if (size > 0) {
+                Entry *entry;
+                transfer->selected = selected;
+                result = 1;
+                func_001634A8(1);
+                entry = (Entry *)((u32)transfer->selected * 8 + (u32)transfer->table);
+                func_00163840(0, transfer->buffer, entry->offset + transfer->base, entry->size, 0, 0, 0);
+                transfer->state = 4;
+            }
+        } else {
+            transfer->selected = selected;
+            transfer->state = 16;
+            result = 1;
+        }
+    }
+    return result;
+}
diff --git a/src/game/004A2C28.c b/src/game/004A2C28.c
new file mode 100644
index 000000000..276486c0e
--- /dev/null
+++ b/src/game/004A2C28.c
@@ -0,0 +1,56 @@
+#include "common.h"
+
+extern s32 func_00163928(void);
+extern void func_001634A8(s32);
+extern void func_00163840(s32, s32, s32, s32, s32, s32, s32);
+extern void func_00469C40(s32, s32);
+
+s32 func_004A2C28(s32 arg0, s32 arg1)
+{
+    s32 result;
+    s32 value;
+    s32 flags = *(s32 *)arg0;
+
+    if ((flags ^ 0x10) == 0) {
+        result = func_00163928();
+        if (result != 0) {
+            goto end;
+        }
+        func_001634A8(1);
+        value = *(s32 *)(arg0 + 0x1C);
+        value = (value << 3) + *(s32 *)(arg0 + 0x14);
+        func_00163840(0, *(s32 *)(arg0 + 0xC),
+                      *(s32 *)value + *(s32 *)(arg0 + 0x18),
+                      *(s32 *)(value + 4), 0, 0, 0);
+        flags = 4;
+        *(s32 *)arg0 = flags;
+        goto done;
+    }
+    if ((flags ^ 8) == 0) {
+        result = func_00163928();
+        if (result != 0) {
+            goto end;
+        }
+        value = 1;
+        goto store;
+    }
+    if ((flags ^ 4) != 0) {
+        goto end;
+    }
+    result = func_00163928();
+    if (result != 0) {
+        goto end;
+    }
+    arg1 = *(s32 *)(arg0 + 0x10);
+    if (arg1 == 0) {
+        value = 2;
+        goto store;
+    }
+    func_00469C40(*(s32 *)(arg0 + 0xC), arg1);
+    value = 2;
+store:
+    *(s32 *)arg0 = value;
+done:
+end:
+    return 1;
+}
diff --git a/src/game/004A4880.c b/src/game/004A4880.c
new file mode 100644
index 000000000..25ec1974d
--- /dev/null
+++ b/src/game/004A4880.c
@@ -0,0 +1,29 @@
+#include "common.h"
+typedef struct {
+    s32 flags;
+    char pad[0xD4];
+    f32 timer;
+    char rest[0x10];
+} State;
+extern u8 D_00307B58[];
+extern s32 func_00505B20(void), func_00504F68(s32, s32), func_00505328(s32, u32), func_005049B8(s32, u32);
+void func_004A4880(void)
+{
+    s32 offset = func_00505B20() * 0xEC;
+    u8 *base = D_00307B58;
+    f32 *first = &((State *)base)->timer;
+    f32 *timer = (f32 *)((char *)first + offset);
+    *timer -= 0.05f;
+    if (*timer <= 0) {
+        func_00504F68(0xE0007, 0);
+        func_00504F68(0xE0008, 0);
+        ((State *)(offset + base))->flags &= ~4;
+    } else if (*timer < 1) {
+        u32 color = (u32)(s32)(*timer * 128.0f) << 24;
+        u32 shadow = (u32)(s32)(*timer * 64.0f) << 24;
+        func_00505328(0xE0007, color | 0xD0D0D0);
+        func_005049B8(0xE0007, shadow);
+        func_00505328(0xE0008, ((u32)(s32)(*timer * 128.0f) << 24) | 0x20F0F0);
+        func_005049B8(0xE0008, shadow);
+    }
+}
diff --git a/src/game/004A8280.c b/src/game/004A8280.c
new file mode 100644
index 000000000..f99d589e5
--- /dev/null
+++ b/src/game/004A8280.c
@@ -0,0 +1,42 @@
+#include "common.h"
+
+typedef struct State {
+    u8 pad0[12];
+    s32 direction;
+    f32 phase0, phase1;
+    u8 pad18[0x5C];
+    s32 first;
+    u8 pad78[0x1C];
+    s32 second;
+} State;
+extern u8 D_00308108[];
+extern s32 D_00221650;
+extern s32 func_00505B20(void);
+extern s32 func_00498918(s32 selector, s32 mode);
+extern u32 func_00498670(f32 *phase, u32 first, f32 step, u32 second);
+extern s32 func_004A1A60(s32 *base, s32 offset);
+extern s32 func_00505328(s32 handle, u32 color);
+extern s32 func_004989C0(s32 context, s32 mode);
+void func_004A8280(void)
+{
+    s32 index = func_00505B20();
+    State *state = (State *)((u32)D_00308108 + (u32)index * 0xB8);
+    u32 color = 0x40000000;
+    s32 value = state->direction;
+    if (value != 0) {
+        u32 target;
+        if (value > 0)
+            target = func_00498918(0, 1);
+        else
+            target = func_00498918(1, 1);
+        target = (target & 0x00FFFFFF) | 0x40000000;
+        color = func_00498670(&state->phase0, 0x40000000, 0.01f, target);
+    }
+    func_00505328(func_004A1A60(&D_00221650, 0x2C), color);
+    color = 0x80D0D0D0;
+    if (state->first <= 0 && state->second > 0) {
+        u32 target = func_004989C0(index, 0);
+        color = func_00498670(&state->phase1, target, 0.05f, 0x80D0D0D0);
+    }
+    func_00505328(func_004A1A60(&D_00221650, 0x30), color);
+}
diff --git a/src/game/004A8430.c b/src/game/004A8430.c
new file mode 100644
index 000000000..c22eb40f9
--- /dev/null
+++ b/src/game/004A8430.c
@@ -0,0 +1,34 @@
+#include "common.h"
+
+extern s32 D_0021DDB4;
+extern f32 func_004539F0(f32, f32);
+
+f32 func_004A8430(const void *arg0)
+{
+    const u8 *arg1;
+    const u8 *object;
+    f32 result;
+    f32 distance;
+    f32 x;
+    f32 y;
+
+    result = 360.0f;
+    arg1 = *(const u8 **)((const u8 *)arg0 + 0x2F00);
+    distance = *(f32 *)(arg1 + 0x140) * *(f32 *)(arg1 + 0x140) +
+               *(f32 *)(arg1 + 0x144) * *(f32 *)(arg1 + 0x144);
+    if (D_0021DDB4 == 4 || (*(s32 *)(arg1 + 0x1A0) & 0x10) != 0) {
+        distance += *(f32 *)(arg1 + 0x148) * *(f32 *)(arg1 + 0x148) +
+                    *(f32 *)(arg1 + 0x14C) * *(f32 *)(arg1 + 0x14C);
+    }
+    if (0.95f < distance) {
+        object = *(const u8 **)((const u8 *)arg0 + 0x2F00);
+        x = *(f32 *)(object + 0x140);
+        y = *(f32 *)(object + 0x144);
+        if (D_0021DDB4 == 4 || (*(s32 *)(object + 0x1A0) & 0x10) != 0) {
+            x += *(f32 *)(object + 0x148);
+            y += *(f32 *)(object + 0x14C);
+        }
+        result = func_004539F0(x, y) * 180.0f / 3.1415927f;
+    }
+    return result;
+}
diff --git a/src/game/004A89E8.c b/src/game/004A89E8.c
new file mode 100644
index 000000000..c36af2479
--- /dev/null
+++ b/src/game/004A89E8.c
@@ -0,0 +1,28 @@
+#include "common.h"
+extern s32 D_0021EDD4;
+extern s32 D_0021EDD8;
+extern u8 D_00308108[];
+extern s32 func_00505B20(void);
+extern s32 func_00498A98(s32, s32);
+extern s32 func_00498120(s32);
+
+u32 func_004A89E8(s32 selection)
+{
+    s32 context = func_00505B20();
+    u32 color = func_00498A98(context, selection);
+    u32 current, other;
+    u32 alpha;
+    if (D_0021EDD4 == 0 && D_0021EDD8 == 1) {
+        current = (u32)D_00308108 + (u32)context * 0xB8;
+        other = (u32)D_00308108 + 0xB8;
+        if (context)
+            other = (u32)D_00308108;
+        if (*(s32 *)(current + 0x24) == 0 &&
+            (!*(s32 *)(other + 0x24) || selection != 2) &&
+            selection != 14 && selection == func_00498120((u32)context < 1)) {
+            alpha = color >> 24;
+            color = ((u32)(s32)((f32)alpha * 0.2f) << 24) | (color & 0xFFFFFF);
+        }
+    }
+    return color;
+}
diff --git a/src/game/004A8E78.c b/src/game/004A8E78.c
new file mode 100644
index 000000000..0ce973400
--- /dev/null
+++ b/src/game/004A8E78.c
@@ -0,0 +1,58 @@
+#include "common.h"
+
+typedef struct {
+    u8 unknown0[0x70];
+    s32 cost;
+    s32 amount;
+    s32 displayedAmount;
+    u8 tail[0x3C];
+} State;
+typedef struct {
+    u8 unknown0[0x26E4];
+    void *inventory;
+} Hero;
+typedef struct {
+    u8 unknown0[0x20];
+    s8 suppressCost;
+} Mode;
+
+extern State D_00308108[];
+extern s32 D_0021EDD4;
+extern Mode *D_0021DFF0;
+extern s32 func_00505B20(void);
+extern s32 func_004A86E0(void);
+extern Hero *func_00510BE8(s32);
+extern s32 func_00548018(s32);
+extern s32 func_00547E30(void *, s32);
+extern s32 func_00547E00(void *, s32);
+extern void func_004A8778(s32, s32);
+extern void func_004A89A0(s32, s32);
+
+void func_004A8E78(void)
+{
+    s32 index = func_00505B20();
+    s32 item = func_004A86E0();
+    State *state = &D_00308108[index];
+    Hero *hero = func_00510BE8(index);
+    s32 cost;
+    s32 amount;
+
+    if (func_00548018(item)) {
+        cost = 0;
+    } else {
+        cost = func_00547E30(hero->inventory, item);
+    }
+    if (D_0021EDD4 == 1 && D_0021DFF0->suppressCost) {
+        cost = 0;
+    }
+    if (state->cost != cost) {
+        state->cost = cost;
+        func_004A8778(index, cost);
+    }
+    amount = func_00547E00(hero->inventory, item);
+    state->amount = amount;
+    if (state->displayedAmount != amount) {
+        state->displayedAmount = amount;
+        func_004A89A0(index, amount);
+    }
+}
diff --git a/src/game/004AD1D8.c b/src/game/004AD1D8.c
new file mode 100644
index 000000000..e5c5d3a56
--- /dev/null
+++ b/src/game/004AD1D8.c
@@ -0,0 +1,47 @@
+#include "common.h"
+
+typedef struct {
+    s16 id;
+    u8 unknown2[0x12];
+    u32 value;
+    u8 tail[4];
+} Record;
+
+typedef struct {
+    u8 unknown0[0x158];
+    s32 selected;
+    u8 tail[0x14];
+} State;
+
+typedef struct {
+    s32 count;
+} Count;
+
+extern u8 D_00308B60[];
+extern State D_00308B80[];
+extern Record D_00308460[64];
+extern Count *D_0021DDA4;
+extern void func_00453608(void *, s32, u32);
+extern void *func_004A2A48(s32);
+extern s32 func_004A2D90(void *, s32, s32);
+extern void *func_004964C8(void);
+
+void func_004AD1D8(void)
+{
+    Record *record;
+    s32 i;
+
+    func_00453608(D_00308B60, 0, 0x20);
+    func_00453608(D_00308B80, 0, 0x5C0);
+    record = D_00308460;
+    do {
+        record->id = -1;
+        record->value = 0;
+        record++;
+    } while ((s32)record < (s32)(D_00308460 + 64));
+    for (i = 0; i < D_0021DDA4->count; i++) {
+        D_00308B80[i].selected = -1;
+    }
+    func_004A2D90(func_004A2A48(0), 0, 0);
+    func_00453608(func_004964C8(), 0, 0x20);
+}
diff --git a/src/game/004B4050.c b/src/game/004B4050.c
new file mode 100644
index 000000000..629956356
--- /dev/null
+++ b/src/game/004B4050.c
@@ -0,0 +1,59 @@
+#include "common.h"
+
+typedef struct {
+    s32 caption, icon, image;
+} Row;
+typedef struct {
+    u8 unknown0[8];
+    u32 icon;
+    u32 color;
+    s32 image;
+    s32 label;
+} Item;
+typedef struct {
+    u32 unknown0, sectorCount;
+} Resource;
+extern Row D_003D1C78[];
+extern s32 D_00221748;
+extern u8 D_003096A8[];
+extern Resource D_001CE0D8[];
+extern s32 func_004A1A60(s32 *, s32);
+extern s32 func_00504F68(u32, s32);
+extern const char *func_0045E038(s32);
+extern s32 func_00505238(u32, const char *);
+extern s32 func_00505328(s32, u32);
+extern s32 func_005054F8(s32, u32);
+extern void func_00499CE0(s32);
+extern s32 func_00499CA0(Resource *, s32);
+extern s32 func_00506120(u32, u32);
+
+static inline u32 address(u32 base, u32 offset)
+{
+    return base + offset;
+}
+
+void func_004B4050(s32 index, Item *item)
+{
+    u32 offset = (u32)index * 12;
+    s32 *caption = (s32 *)address(offset, (u32)D_003D1C78);
+    s32 *icon;
+    s32 *image;
+    s32 *cache;
+    u32 handle;
+
+    func_00504F68(func_004A1A60(&D_00221748, *caption), 1);
+    icon = (s32 *)address(offset, address((u32)D_003D1C78, 4));
+    func_00504F68(func_004A1A60(&D_00221748, *icon), 1);
+    handle = func_004A1A60(&D_00221748, *caption);
+    func_00505238(handle, func_0045E038(item->label));
+    func_00505328(func_004A1A60(&D_00221748, *icon), item->color);
+    func_005054F8(func_004A1A60(&D_00221748, *icon), item->icon);
+    image = (s32 *)address(offset, address((u32)D_003D1C78, 8));
+    func_00504F68(func_004A1A60(&D_00221748, *image), 1);
+    cache = (s32 *)address((u32)index << 2, address((u32)D_003096A8, 0x168));
+    if (*cache)
+        func_00499CE0(*cache);
+    *cache = func_00499CA0((Resource *)((u32)D_001CE0D8 + ((u32)item->image << 3)), -1);
+    func_005054F8(func_004A1A60(&D_00221748, *image), 1);
+    func_00506120(func_004A1A60(&D_00221748, *image), *cache);
+}
diff --git a/src/game/004B6740.c b/src/game/004B6740.c
new file mode 100644
index 000000000..316ceb1b7
--- /dev/null
+++ b/src/game/004B6740.c
@@ -0,0 +1,38 @@
+/* cflags: -G0 -Wuninitialized -G8 */
+#include "pal/decomp.h"
+typedef long long s128; typedef unsigned long long u128;
+
+s32 func_0045E038(M2C_UNK);
+void func_004A01F0(s32, s32);
+void func_004B5DF8(s32);
+void func_004B5E18(s32, s32, s32, s32);
+typedef int (*Callback)();
+M2C_UNK func_004B5E70(s32, Callback, s32);
+extern u8 D_00171B66[];
+u8 D_0021F7E9 = 0;
+typedef struct { u8 pad[12]; s32 value; u8 tail[488]; } Record;
+extern Record D_003098F0[];
+extern int D_004B6C58();
+extern int D_004B72E8();
+extern int D_004B7558();
+extern int D_004B75B8();
+extern int D_004B7610();
+extern int D_004B7668();
+
+void func_004B6740(s32 arg0) {
+    M2C_UNK var_16;
+
+    var_16 = 0;
+    func_004A01F0(arg0, D_003098F0[arg0].value);
+    func_004B5DF8(arg0);
+    func_004B5E18(arg0, func_0045E038(0x235F), (s32)&D_004B72E8, 1);
+    func_004B5E18(arg0, func_0045E038(0x31D5), (s32)&D_004B7668, 1);
+    func_004B5E18(arg0, func_0045E038(0x31D4), (s32)&D_004B75B8, 1);
+    if ((D_00171B66[0] != 0) || (D_0021F7E9 != 0)) {
+        var_16 = 1;
+    }
+    func_004B5E18(arg0, func_0045E038(0x3264), (s32)&D_004B7610, var_16);
+    func_004B5E18(arg0, func_0045E038(0x31D3), (s32)&D_004B7558, var_16);
+    func_004B5E18(arg0, func_0045E038(0x362D), (s32)&D_004B6C58, 1);
+    func_004B5E70(arg0, &D_004B6C58, func_0045E038(0x31CF));
+}
diff --git a/src/game/004B83C8.c b/src/game/004B83C8.c
new file mode 100644
index 000000000..6192e21e8
--- /dev/null
+++ b/src/game/004B83C8.c
@@ -0,0 +1,46 @@
+#include "common.h"
+
+typedef struct P_004B83C8 {
+    u8 pad0[0x2F10];
+    s32 unk2F10;
+} P_004B83C8;
+
+s32 D_0021F840 = 0;
+s32 D_0021F868[2] = { 0 };
+extern s32 D_0021EDD4;
+extern s32 D_0021EDD8;
+extern s32 D_001711D0[];
+extern s32 D_00171D50[][4];
+extern s32 D_00171E00[][10];
+extern s32 D_00221790;
+extern s32 D_003D9390[];
+extern s32 func_0045E038(s32);
+extern void func_00497980(s32);
+extern s32 func_004A1A60(s32 *, s32);
+extern void func_00505238(s32, s32);
+extern s32 func_00505B20(void);
+extern P_004B83C8 *func_00510BE8(s32);
+
+void func_004B83C8(s32 arg0) {
+    s32 v;
+    s32 idx;
+    s32 j;
+    s32 *p;
+    s32 *q;
+    s32 t;
+    s32 s;
+
+    v = func_00505B20();
+    idx = func_00510BE8((D_0021EDD4 == 0 && D_0021EDD8 == 1) ? D_0021F840 != 1 : v)->unk2F10;
+    j = D_001711D0[idx];
+    p = &D_00171E00[j][idx];
+    q = &D_00171D50[j][idx];
+    if (arg0 != 0) {
+        t = (*p & 1) ^ 1;
+        *q = t;
+        *p = t;
+        func_00497980(0x10);
+    }
+    s = func_004A1A60(&D_00221790, D_003D9390[0]);
+    func_00505238(s, func_0045E038(D_0021F868[*p]));
+}
diff --git a/src/game/004B84D0.c b/src/game/004B84D0.c
new file mode 100644
index 000000000..413ccba38
--- /dev/null
+++ b/src/game/004B84D0.c
@@ -0,0 +1,47 @@
+#include "common.h"
+
+// D_0021F840 and D_0021F870 must be defined in this translation unit (retail reaches them through
+// $gp outside a delay slot); D_0021F840 is also defined in src/game/004B85D8.c, so landing this
+// means putting both functions in one file.
+
+typedef struct {
+    u8 prefix[0x2F10];
+    s32 slot;
+} Player;
+extern s32 func_00505B20(void);
+extern Player *func_00510BE8(s32 arg0);
+extern void func_00497980(s32 arg0);
+extern s32 func_004A1A60(s32 *arg0, s32 arg1);
+extern s32 func_0045E038(s32);
+extern s32 func_00505238(s32, s32);
+extern s32 D_0021EDD4;
+extern s32 D_0021EDD8;
+s32 D_0021F840 = 0;
+s32 D_0021F870[2] = { 0x192, 0x193 };
+extern s32 D_001711D0[];
+extern s32 D_00171D80[][4];
+extern s32 D_00171E78[][10];
+extern s32 D_00221790;
+extern s32 D_003D93A4[];
+
+void func_004B84D0(s32 arg0) {
+    s32 slot;
+    s32 n;
+    s32 v;
+    s32 t;
+    s32 *on;
+    s32 *shown;
+
+    n = func_00505B20();
+    slot = func_00510BE8((D_0021EDD4 == 0 && D_0021EDD8 == 1) ? (D_0021F840 != 1) : n)->slot;
+    on = &D_00171E78[D_001711D0[slot]][slot];
+    shown = &D_00171D80[D_001711D0[slot]][slot];
+    if (arg0) {
+        v = (*on & 1) ^ 1;
+        *shown = v;
+        *on = v;
+        func_00497980(0x10);
+    }
+    t = func_004A1A60(&D_00221790, D_003D93A4[0]);
+    func_00505238(t, func_0045E038(D_0021F870[*on]));
+}
diff --git a/src/game/004B9240.c b/src/game/004B9240.c
new file mode 100644
index 000000000..fa0a14500
--- /dev/null
+++ b/src/game/004B9240.c
@@ -0,0 +1,31 @@
+#include "common.h"
+
+extern s32 D_002217B8;
+extern s32 D_002217B0;
+extern s32 D_001CDAA0;
+extern s32 func_00505B20(void);
+extern void func_004B96A8(void);
+extern void func_004B9440(void);
+extern s32 func_00499CA0(s32, s32);
+extern s32 func_004A1A60(const s32 *, s32);
+extern void func_005054F8(s32, s32);
+extern void func_00506120(s32, s32);
+extern void func_0049D308(s32, s32, s32);
+extern void func_0049D170(s32, s32, s32);
+extern void func_0049D280(s32, s32);
+extern void func_0049C290(s32, s32);
+
+void func_004B9240(void) {
+    s32 index = func_00505B20();
+    s32 *record = (s32 *)((index << 4) + (s32)&D_002217B8);
+    func_004B96A8();
+    func_004B9440();
+    record[0] = 1;
+    record[3] = func_00499CA0((s32)&D_001CDAA0, -1);
+    func_005054F8(func_004A1A60(&D_002217B0, 1), 1);
+    func_00506120(func_004A1A60(&D_002217B0, 1), record[3]);
+    func_0049D308(index, 0, D_002217B0);
+    func_0049D170(index, 0, func_004A1A60(&D_002217B0, 1));
+    func_0049D280(index, 1);
+    func_0049C290(index, 0);
+}
diff --git a/src/game/004B9440.c b/src/game/004B9440.c
new file mode 100644
index 000000000..378356dbb
--- /dev/null
+++ b/src/game/004B9440.c
@@ -0,0 +1,24 @@
+#include "common.h"
+extern s32 D_002217B8;
+extern s32 D_002217B0;
+s32 D_0021F8A0 = 12059;
+s32 D_0021F8B0 = 12643;
+extern s32 D_003D9488[][13];
+extern s32 func_00505B20(void);
+extern u32 func_004A1A60(const s32 *, s32);
+extern const char *func_0045E038(s32);
+extern s32 func_00505238(u32, const char *);
+s32 func_004B9440(void)
+{
+    s32 index = func_00505B20();
+    s32 *record = (s32 *)((u32)&D_002217B8 + ((u32)index << 4));
+    u32 handle = func_004A1A60(&D_002217B0, 100);
+    s32 i;
+    func_00505238(handle, func_0045E038(*(s32 *)((u32)&D_0021F8A0 + (u32)record[1] * 4)));
+    for (i = 0; i < 13; i++) {
+        handle = func_004A1A60(&D_002217B0, i + 180);
+        func_00505238(handle, func_0045E038(D_003D9488[record[1]][i]));
+    }
+    handle = func_004A1A60(&D_002217B0, 182);
+    return func_00505238(handle, func_0045E038(*(s32 *)((u32)&D_0021F8B0 + (u32)record[2] * 4)));
+}
diff --git a/src/game/004C1FA8.c b/src/game/004C1FA8.c
new file mode 100644
index 000000000..527183626
--- /dev/null
+++ b/src/game/004C1FA8.c
@@ -0,0 +1,78 @@
+#include "common.h"
+
+typedef struct State {
+    s32 phase, unknown04;
+    u32 flags;
+    s32 choice, mode;
+} State;
+extern u8 D_0030B7F8[];
+extern s32 func_00505B20(void);
+extern void func_005014B0(void *descriptor);
+extern void func_004C4208(void);
+extern void func_004C44E8(void);
+extern void func_004C4698(void);
+extern void func_0049C248(s32 context, s32 channel);
+extern void func_0049C390(s32 context, s32 channel);
+extern void func_0049C328(s32 context, s32 channel, s32 enabled);
+extern void func_004C21A0(void);
+extern void func_004C21E8(void);
+extern void func_004C29A0(void);
+extern void func_004C2BE0(void);
+extern void func_004C2750(void);
+extern void func_004C2490(void);
+extern void func_004C2558(void);
+extern void func_004C2DE8(void);
+
+void func_004C1FA8(void *descriptor)
+{
+    s32 context = func_00505B20();
+    State *state = (State *)((u32)D_0030B7F8 + (u32)context * 0x74u);
+
+    switch (state->phase) {
+    case 0:
+        state->phase = 1;
+        break;
+    case 1:
+        func_004C4208();
+        break;
+    case 2:
+        func_004C44E8();
+        break;
+    case 3:
+        func_004C4698();
+        break;
+    case 4:
+        func_005014B0(descriptor);
+        break;
+    }
+    if (state->phase == 1) {
+        if (state->mode == 0) {
+            func_0049C248(context, 2);
+            func_0049C390(context, 1);
+            func_0049C328(context, 0, 1);
+        } else {
+            func_0049C248(context, 2);
+            func_0049C390(context, 0);
+            func_0049C328(context, 1, 1);
+        }
+    } else {
+        func_0049C390(context, 0);
+        func_0049C390(context, 1);
+    }
+    if (state->flags & 1)
+        func_004C21A0();
+    if (state->flags & 2)
+        func_004C21E8();
+    if (state->flags & 0x10)
+        func_004C29A0();
+    if (state->flags & 0x40)
+        func_004C2BE0();
+    if (state->flags & 0x20)
+        func_004C2750();
+    if (state->flags & 4)
+        func_004C2490();
+    if (state->flags & 8)
+        func_004C2558();
+    if (state->flags & 0x80)
+        func_004C2DE8();
+}
diff --git a/src/game/004C33D0.c b/src/game/004C33D0.c
new file mode 100644
index 000000000..c9f84dc76
--- /dev/null
+++ b/src/game/004C33D0.c
@@ -0,0 +1,37 @@
+#include "common.h"
+
+typedef struct E_004C33D0 {
+    u8 pad0[0x18];
+    s32 unk18;
+    u8 pad1C[0x58 - 0x1C];
+    s8 unk58[10];
+    u8 pad62[0x74 - 0x62];
+} E_004C33D0;
+
+typedef struct T_004C33D0 {
+    s32 unk0;
+    s32 unk4;
+} T_004C33D0;
+
+extern E_004C33D0 D_0030B7F8[];
+extern s32 D_00221888;
+extern T_004C33D0 D_003D22E0[];
+extern s32 D_003D2320[];
+extern T_004C33D0 D_003D2248[];
+extern s32 func_004A1A60(s32 *, s32);
+extern s32 func_00505328(s32, u32);
+extern s32 func_00505B20(void);
+
+void func_004C33D0(void) {
+    E_004C33D0 *e;
+    s32 i;
+
+    e = &D_0030B7F8[func_00505B20()];
+    func_00505328(func_004A1A60(&D_00221888, D_003D22E0[e->unk18].unk0), 0x80808080);
+    func_00505328(func_004A1A60(&D_00221888, D_003D2320[e->unk18]), 0x80808080);
+    for (i = 0; i < 10; i++) {
+        if (e->unk58[i] == e->unk18 + 1) {
+            func_00505328(func_004A1A60(&D_00221888, D_003D2248[i].unk0), 0x80808080);
+        }
+    }
+}
diff --git a/src/game/004C44E8.c b/src/game/004C44E8.c
new file mode 100644
index 000000000..fa870846a
--- /dev/null
+++ b/src/game/004C44E8.c
@@ -0,0 +1,82 @@
+#include "common.h"
+
+typedef struct State {
+    u8 prefix[0x18];
+    s32 level;
+} State;
+extern u16 D_001F620C[];
+extern u8 D_0030B7F8[];
+extern s32 func_0045DC60(s16 message, s16 id);
+extern s32 func_00505B20(void);
+extern s32 func_004983E8(s32 mode);
+extern void func_004C44B8(void);
+extern void func_004C4018(void);
+extern void func_004C40C8(void);
+extern void func_004C41F8(void);
+extern s32 func_004C3310(s32 level);
+extern void func_004C37A0(s32 next);
+extern void func_004C3EF8(void);
+extern void func_00497980(s32 id);
+extern void func_004C30B8(s32 next);
+extern void func_004C3CE0(void);
+
+void func_004C44E8(void)
+{
+    s32 first;
+    s32 last;
+    State *state;
+
+    if (D_001F620C[0] != 0) {
+        func_0045DC60(0x2FAF, 0x684);
+        func_0045DC60(0x2FB0, 0x685);
+        func_0045DC60(0x2FB1, 0x686);
+    }
+    first = 0;
+    state = (State *)((u32)D_0030B7F8 + (u32)func_00505B20() * 0x74u);
+    last = 7;
+    switch (func_004983E8(6)) {
+    case 13:
+        func_004C44B8();
+        break;
+    case 1:
+        func_004C4018();
+        break;
+    case 3:
+        func_004C40C8();
+        break;
+    case 4:
+        func_004C41F8();
+        break;
+    case 7:
+        while (first < 8 && !func_004C3310(first)) {
+            first++;
+        }
+        if (first < state->level) {
+            func_004C37A0(1);
+            break;
+        }
+    case 2:
+        func_004C3EF8();
+        break;
+    case 8:
+        while (last >= 0 && !func_004C3310(last)) {
+            last--;
+        }
+        if (state->level < last) {
+            func_004C37A0(0);
+        } else {
+            func_00497980(4);
+        }
+        break;
+    case 9:
+    case 10:
+        func_004C30B8(1);
+        func_004C3CE0();
+        break;
+    case 11:
+    case 12:
+        func_004C30B8(0);
+        func_004C3CE0();
+        break;
+    }
+}
diff --git a/src/game/004C4698.c b/src/game/004C4698.c
new file mode 100644
index 000000000..86de1823a
--- /dev/null
+++ b/src/game/004C4698.c
@@ -0,0 +1,77 @@
+#include "common.h"
+
+typedef struct State {
+    u8 prefix[0x14];
+    s32 level;
+} State;
+extern u16 D_001F61C4[];
+extern u8 D_0030B7F8[];
+extern s32 func_0045DC60(s16 message, s16 id);
+extern s32 func_00505B20(void);
+extern s32 func_004983E8(s32 mode);
+extern void func_004C44B8(void);
+extern void func_004C3B88(void);
+extern s32 func_004C38E8(s32 level);
+extern void func_004C3B20(s32 next);
+extern void func_004C3EF8(void);
+extern void func_00497980(s32 id);
+extern void func_004C30B8(s32 next);
+extern void func_004C3C38(void);
+
+void func_004C4698(void)
+{
+    s32 first;
+    s32 last;
+    State *state;
+
+    if (D_001F61C4[0] != 0) {
+        func_0045DC60(0x2FA8, 0x67D);
+        func_0045DC60(0x2FA9, 0x67E);
+        func_0045DC60(0x2FAA, 0x67F);
+        func_0045DC60(0x2966, 0x2DD);
+    }
+    first = 0;
+    state = (State *)((u32)D_0030B7F8 + (u32)func_00505B20() * 0x74u);
+    last = 9;
+    switch (func_004983E8(6)) {
+    case 13:
+        func_004C44B8();
+        break;
+    case 1:
+        func_004C3B88();
+    case 2:
+    refresh:
+        func_004C3EF8();
+        break;
+    case 7:
+        while (first < 9 && !func_004C38E8(first)) {
+            first++;
+        }
+        if (first < state->level) {
+            func_004C3B20(1);
+        } else {
+            goto refresh;
+        }
+        break;
+    case 8:
+        while (last >= 0 && !func_004C38E8(last)) {
+            last--;
+        }
+        if (state->level < last) {
+            func_004C3B20(0);
+        } else {
+            func_00497980(4);
+        }
+        break;
+    case 9:
+    case 10:
+        func_004C30B8(1);
+        func_004C3C38();
+        break;
+    case 11:
+    case 12:
+        func_004C30B8(0);
+        func_004C3C38();
+        break;
+    }
+}
diff --git a/src/game/004C6BA0.c b/src/game/004C6BA0.c
new file mode 100644
index 000000000..757ef21ce
--- /dev/null
+++ b/src/game/004C6BA0.c
@@ -0,0 +1,66 @@
+#include "common.h"
+typedef struct Data {
+    u8 a, locked, enabled, pad;
+    s32 id, kind;
+} Data;
+typedef struct Item {
+    u8 pad[8];
+    Data *data;
+    u8 tail[12];
+} Item;
+typedef struct List {
+    u8 pad[0x34];
+    Item *items;
+    u8 pad2[0x18];
+    s32 count, index;
+    u8 tail[0x20];
+} List;
+typedef struct State {
+    u8 pad[0xAB4];
+    List list;
+    s32 which;
+} State;
+typedef struct Descriptor {
+    u8 pad[0x14];
+    s32 available;
+} Descriptor;
+extern State D_0030B9D8[];
+extern s32 func_00505B20(void), func_0054AB08(s32, s32);
+extern Descriptor *func_0054A998(s32);
+static inline s32 locked(Data *d)
+{
+    return d->locked;
+}
+static inline s32 enabled(Data *d)
+{
+    return d->enabled;
+}
+static inline s32 count(List *l)
+{
+    return l->count;
+}
+static inline Item *item(List *l, s32 index)
+{
+    if (index < 0) {
+        index = l->index;
+        if (index < 0)
+            return 0;
+    }
+    return (Item *)((u32)l->items + (u32)index * 24);
+}
+s32 func_004C6BA0(void)
+{
+    s32 i = 0, found = -1;
+    State *p = (State *)((u32)D_0030B9D8 + (u32)func_00505B20() * 0xB30);
+    for (; i < count(&p->list); i++) {
+        if (found == -1) {
+            Data *d = item(&p->list, i)->data;
+            if (d->kind != 1) {
+                Descriptor *desc = func_0054A998(func_0054AB08(p->which, d->id));
+                if (desc->available && !locked(d) && !enabled(d))
+                    found = i;
+            }
+        }
+    }
+    return found;
+}
diff --git a/src/game/004C7168.c b/src/game/004C7168.c
new file mode 100644
index 000000000..04668e362
--- /dev/null
+++ b/src/game/004C7168.c
@@ -0,0 +1,35 @@
+#include "common.h"
+
+typedef struct {
+    u8 prefix[0x50];
+    s32 count, index;
+} List;
+typedef struct {
+    u8 prefix[0x10];
+    u32 flags;
+    u8 gap[0xAA0];
+    List list;
+    u8 tail[0x24];
+} State;
+extern State D_0030B9D8[];
+extern s32 func_00505B20(void);
+extern void func_004A1358(List *);
+extern void func_004A1310(List *);
+extern void func_00497980(s32);
+void func_004C7168(s32 direction)
+{
+    s32 index = func_00505B20();
+    State *state = D_0030B9D8 + index;
+    List *list = &state->list;
+    if (list->count >= 2) {
+        if (direction)
+            func_004A1358(list);
+        else
+            func_004A1310(list);
+        if (state->list.count >= 2)
+            func_00497980(10);
+        else
+            func_00497980(4);
+        D_0030B9D8[index].flags |= 3;
+    }
+}
diff --git a/src/game/004C9090.c b/src/game/004C9090.c
new file mode 100644
index 000000000..929d394c6
--- /dev/null
+++ b/src/game/004C9090.c
@@ -0,0 +1,40 @@
+#include "common.h"
+typedef struct {
+    s32 kind, other, count;
+} Data;
+typedef struct {
+    s32 a, b;
+    Data *data;
+    char tail[12];
+} Item;
+typedef struct {
+    char pad[0x34];
+    Item *items;
+    char gap[0x18];
+    s32 count, index;
+} List;
+extern List D_0030E494;
+extern s32 func_004E6FA0(Data *), func_00505B20(void);
+extern const char *func_0045E038(s32);
+extern void D_004C8FB0(s32), func_00497980(s32), func_0049E790(s32, const char *, void (*)(s32), s32, s32, s32, s32, f32);
+static inline Item *selected(List *l)
+{
+    if (l->index < 0)
+        return 0;
+    return l->items + l->index;
+}
+void func_004C9090(void)
+{
+    if (D_0030E494.count) {
+        Data *d = selected(&D_0030E494)->data;
+        if (func_004E6FA0(d)) {
+            if (d->count <= 0 || d->kind == 1)
+                D_004C8FB0(1);
+            else {
+                s32 index = func_00505B20();
+                func_0049E790(index, func_0045E038(0x8D0), D_004C8FB0, 3, 0, 0, 0, -1.0f);
+            }
+        } else
+            func_00497980(4);
+    }
+}
diff --git a/src/game/004CBB98.c b/src/game/004CBB98.c
new file mode 100644
index 000000000..1a256bdf5
--- /dev/null
+++ b/src/game/004CBB98.c
@@ -0,0 +1,75 @@
+#include "common.h"
+
+typedef struct State {
+    u8 prefix[0x38];
+    s32 resource;
+    u8 rest[0x28];
+} State;
+typedef struct Resource {
+    s32 type, id;
+    u32 value;
+    u32 rest[3];
+} Resource;
+typedef struct Player {
+    u8 prefix[0x26E4];
+    void *settings;
+} Player;
+typedef struct Item {
+    u8 prefix[0x36];
+    u16 value;
+} Item;
+extern u8 D_0030EAA0[];
+extern s32 D_00221920;
+typedef struct Widgets {
+    u8 prefix[0x20];
+    s32 first, second, third, fourth;
+} Widgets;
+extern Widgets D_003D2738;
+extern void func_00498C98(Resource *);
+extern s32 func_004A1A60(s32 *, s32);
+extern s32 func_00505328(s32, u32);
+extern s32 func_005054F8(s32, u32);
+extern s32 func_00504F68(s32, s32);
+extern s32 func_004CC978(void);
+extern Player *func_00510BE8(s32);
+extern s32 func_00548DA0(void *, s32);
+extern Item *func_00548D28(s32, s32);
+
+void func_004CBB98(s32 context)
+{
+    Resource descriptor;
+    State *state = (State *)((u32)D_0030EAA0 + (u32)context * 100);
+    Widgets *items = &D_003D2738;
+    Player *player;
+    descriptor.type = 5;
+    descriptor.id = state->resource;
+    func_00498C98(&descriptor);
+    func_00505328(func_004A1A60(&D_00221920, items->first), 0x80808080);
+    func_005054F8(func_004A1A60(&D_00221920, items->first), descriptor.value);
+    func_00504F68(func_004A1A60(&D_00221920, items->first), 1);
+    func_00505328(func_004A1A60(&D_00221920, items->second), 0x80808080);
+    {
+        s32 handle = func_004A1A60(&D_00221920, items->second);
+        func_005054F8(handle, func_004CC978());
+    }
+    func_00504F68(func_004A1A60(&D_00221920, items->second), 1);
+    player = func_00510BE8(context);
+    if (func_00548DA0(player->settings, 17)) {
+        s32 handle;
+        func_00505328(func_004A1A60(&D_00221920, items->third), 0x80808080);
+        handle = func_004A1A60(&D_00221920, items->third);
+        func_005054F8(handle, func_00548D28(17, 0)->value);
+        func_00504F68(func_004A1A60(&D_00221920, items->third), 1);
+    } else {
+        func_00504F68(func_004A1A60(&D_00221920, items->third), 0);
+    }
+    if (func_00548DA0(player->settings, 18)) {
+        s32 handle;
+        func_00505328(func_004A1A60(&D_00221920, 51), 0x80808080);
+        handle = func_004A1A60(&D_00221920, 51);
+        func_005054F8(handle, func_00548D28(18, 0)->value);
+        func_00504F68(func_004A1A60(&D_00221920, 51), 1);
+    } else {
+        func_00504F68(func_004A1A60(&D_00221920, D_003D2738.fourth), 0);
+    }
+}
diff --git a/src/game/004CDF08.c b/src/game/004CDF08.c
new file mode 100644
index 000000000..fb93c0181
--- /dev/null
+++ b/src/game/004CDF08.c
@@ -0,0 +1,51 @@
+#include "common.h"
+typedef struct {
+    const char *label;
+    s32 icon;
+} Data;
+typedef struct {
+    u8 prefix[8];
+    Data *data;
+    u8 suffix[12];
+} Item;
+typedef struct {
+    u8 prefix[0x34];
+    Item *items;
+    u8 gap[0x18];
+    s32 count, index;
+} List;
+typedef struct {
+    s32 a, b, flags;
+    s32 handle;
+    u8 gap[0x200];
+    List list;
+} State;
+extern u8 D_0030ECC0[], D_001CDD48[];
+extern s32 D_00221940;
+extern s32 func_00505B20(void), func_00499CA0(const void *, s32), func_004A1A60(s32 *, s32), func_00506120(s32, s32);
+extern void func_00499CE0(s32);
+static inline s32 count(List *list)
+{
+    return list->count;
+}
+static inline Item *selected(List *list)
+{
+    if (list->index < 0)
+        return NULL;
+    return (Item *)((u32)list->items + (u32)list->index * 24);
+}
+void func_004CDF08(void)
+{
+    State *state = (State *)((u32)D_0030ECC0 + (u32)func_00505B20() * 0x280);
+    if (count(&state->list) > 0) {
+        Data *data = selected(&state->list)->data;
+        const void *resource = (void *)((u32)D_001CDD48 + ((u32)data->icon << 3));
+        if (state->handle) {
+            func_00499CE0(state->handle);
+            state->handle = 0;
+        }
+        state->handle = func_00499CA0(resource, -1);
+        func_00506120(func_004A1A60(&D_00221940, 3), state->handle);
+    }
+    state->flags &= ~2;
+}
diff --git a/src/game/004CEB68.c b/src/game/004CEB68.c
new file mode 100644
index 000000000..76250f4f6
--- /dev/null
+++ b/src/game/004CEB68.c
@@ -0,0 +1,35 @@
+#include "common.h"
+
+extern s32 func_004A1730(void *);
+extern void func_004CED70(void);
+extern void func_004CEDB0(void);
+extern void func_004CEE70(void);
+extern void func_004CEFB0(void);
+extern void func_005014B0(s32 a0);
+extern s32 func_00505B20(void);
+extern u8 D_0030F820[];
+
+void func_004CEB68(s32 arg0) {
+    u8 *entry = D_0030F820 + func_00505B20() * 0x103C;
+    switch (*(s32 *)entry) {
+    case 1:
+        *(s32 *)entry = 0;
+        break;
+    case 2:
+        func_005014B0(arg0);
+        break;
+    case 0:
+        func_004CEFB0();
+        break;
+    }
+    if (*(s32 *)(entry + 8) & 1) {
+        func_004CED70();
+    }
+    if (*(s32 *)(entry + 8) & 2) {
+        func_004CEDB0();
+    }
+    func_004A1730(entry + 0xF90);
+    if (*(s32 *)(entry + 8) & 4) {
+        func_004CEE70();
+    }
+}
diff --git a/src/game/004CF950.c b/src/game/004CF950.c
new file mode 100644
index 000000000..a8448b882
--- /dev/null
+++ b/src/game/004CF950.c
@@ -0,0 +1,45 @@
+#include "common.h"
+typedef struct {
+    char pad[0x30];
+    s32 label;
+} Data;
+typedef struct {
+    s32 a, b;
+    Data *data;
+    char tail[12];
+} Item;
+typedef struct {
+    char pad[0x34];
+    Item *items;
+    char gap[0x18];
+    s32 count, index;
+} List;
+typedef struct {
+    s32 a, b, flags;
+    char pad[0x968];
+    List list;
+    char tail[0x14];
+} State;
+extern State D_00316D00[];
+extern s32 D_00221980;
+extern s32 func_00505B20(void), func_004A1A60(s32 *, s32), func_00505238(s32, const char *), func_00504F68(s32, s32);
+extern const char *func_0045E038(s32);
+static inline Item *selected(List *l)
+{
+    if (l->index < 0)
+        return 0;
+    return l->items + l->index;
+}
+void func_004CF950(void)
+{
+    State *p = D_00316D00 + func_00505B20();
+    List *l = &p->list;
+    if (l->count > 0) {
+        Data *d = selected(l)->data;
+        s32 handle = func_004A1A60(&D_00221980, 0xD);
+        func_00505238(handle, func_0045E038(d->label));
+        func_00504F68(func_004A1A60(&D_00221980, 0xD), 1);
+    } else
+        func_00504F68(func_004A1A60(&D_00221980, 0xD), 0);
+    p->flags &= ~2;
+}
diff --git a/src/game/004D3060.c b/src/game/004D3060.c
new file mode 100644
index 000000000..b93a565f1
--- /dev/null
+++ b/src/game/004D3060.c
@@ -0,0 +1,36 @@
+#include "common.h"
+typedef struct {
+    s32 mode;
+    u8 pad[0x4B];
+    u8 active;
+} State;
+extern State D_003D9BE0;
+extern s32 D_002214D0;
+extern void *D_0021DDCC;
+u8 D_0021FB2C = 0;
+extern void func_0047EF38(void), func_00489458(s32), func_0048A060(void *, s32), func_00501498(void *), func_004E21D8(u32, s32, void *), func_0048FA80(void *);
+extern s32 func_00158868(s32), func_0049B120(s32), func_00157F98(void), func_00505B20(void), func_00505AD8(s32), func_00505C90(void *);
+extern void *func_004D36E0(void);
+void func_004D3060(s32 mode)
+{
+    s32 old;
+    func_0047EF38();
+    func_00158868(0xCD);
+    if (func_0049B120(0) != 24)
+        func_00489458(0);
+    func_0048A060(&D_002214D0, 1);
+    func_00157F98();
+    if (!D_003D9BE0.active)
+        D_003D9BE0.mode = mode;
+    old = func_00505B20();
+    func_00505AD8(4);
+    func_00501498(func_004D36E0());
+    func_00505C90(func_004D36E0());
+    func_00505AD8(old);
+    if (D_0021FB2C) {
+        D_0021FB2C = 0;
+        func_004E21D8(0xFFFFFFFFU, 0, 0);
+    }
+    if (D_0021DDCC)
+        func_0048FA80(D_0021DDCC);
+}
diff --git a/src/game/004D4C58.c b/src/game/004D4C58.c
new file mode 100644
index 000000000..f54adfb82
--- /dev/null
+++ b/src/game/004D4C58.c
@@ -0,0 +1,79 @@
+#include "common.h"
+typedef struct {
+    s32 mode;
+    u32 flags;
+    char pad8[0x1304];
+    char context[0x6C];
+    char pad1378[0x3A];
+} State;
+extern State D_0031B9B8;
+extern u32 D_002211CC;
+extern void func_005014B0(void *);
+extern void func_004D5950(void);
+extern void func_004D51C0(void);
+extern s32 func_004A1730(void *);
+extern void func_004D52D0(void);
+extern void func_004D5550(void);
+extern void *func_0046D820(s32);
+extern f32 func_00453940(f32);
+extern void func_0046E728(void *);
+extern void func_0046EDD8(void *);
+extern void func_004706F0(void *);
+extern void func_00479820(void *, void *, s32, s32);
+void func_004D4C58(void *arg0)
+{
+    void *first;
+    void *second;
+    u32 packed;
+    s32 phase;
+    s32 shade;
+    f32 volume;
+    switch (D_0031B9B8.mode) {
+    case 0:
+        D_0031B9B8.mode = 2;
+        break;
+    case 2:
+        func_004D5950();
+        break;
+    case 1:
+        func_005014B0(arg0);
+        break;
+    }
+    {
+        State *state = &D_0031B9B8;
+        if (state->flags & 1) {
+            func_004D51C0();
+        }
+        func_004A1730(state->context);
+        if (state->flags & 2) {
+            func_004D52D0();
+        }
+        if (state->flags & 4) {
+            func_004D5550();
+        }
+        first = func_0046D820(0);
+        second = func_0046D820(1);
+        if (first == NULL || second == NULL) {
+            return;
+        }
+        phase = ((s32)D_002211CC & 0x3F) - 0x20;
+        shade = (s32)(func_00453940((f32)phase * 0.09817477315664291f) * 32.0f + 96.0f);
+        packed = (u32)shade;
+        packed = (packed << 24) | (packed << 16) | (packed << 8) | 0x80;
+        *(u32 *)((u32)first + 0x60) = packed;
+        volume = (f32)((s32)(D_002211CC & 0x1FF) - 0x100) * 0.012271846644580364f;
+        volume = func_00453940(volume) * 0.5f;
+        *(f32 *)((u32)first + 0xF8) = volume;
+        func_0046E728(first);
+        func_0046EDD8(first);
+        func_004706F0(first);
+        *(u32 *)((u32)second + 0x60) = packed;
+        volume = (f32)((s32)(D_002211CC & 0x1FF) - 0x100) * 0.012271846644580364f;
+        volume = func_00453940(volume) * 0.5f;
+        *(f32 *)((u32)second + 0xF8) = volume;
+        func_0046E728(second);
+        func_0046EDD8(second);
+        func_004706F0(second);
+        func_00479820(first, second, 5, 0);
+    }
+}
diff --git a/src/game/004D6378.c b/src/game/004D6378.c
new file mode 100644
index 000000000..ee39c73db
--- /dev/null
+++ b/src/game/004D6378.c
@@ -0,0 +1,26 @@
+#include "common.h"
+
+extern s32 D_0031D100[];
+extern s32 D_00221AD8;
+extern u8 D_001CDAF0[];
+extern s32 func_00505B20(void);
+extern void func_00501638(s32, s32, s32);
+extern void func_00505B70(s32, s32);
+extern s32 func_004A1A60(const s32 *, s32);
+extern const char *func_0045E038(s32);
+extern s32 func_00505238(u32, const char *);
+extern s32 func_00499CA0(s32, s32);
+extern void func_005054F8(s32, s32);
+extern void func_00506120(s32, s32);
+
+void func_004D6378(void) {
+    s32 *record = (s32 *)(func_00505B20() * 0x528 + (s32)D_0031D100);
+    func_00501638((s32)&D_00221AD8, 0x29, -1);
+    func_00505B70(0xF, D_00221AD8);
+    func_00505238(func_004A1A60(&D_00221AD8, 0xA), func_0045E038(0x2350));
+    func_00505238(func_004A1A60(&D_00221AD8, 9), func_0045E038(0x31CE));
+    func_00505238(func_004A1A60(&D_00221AD8, 0xB), func_0045E038(0x2F0B));
+    record[2] = func_00499CA0((s32)D_001CDAF0, -1);
+    func_005054F8(func_004A1A60(&D_00221AD8, 4), 1);
+    func_00506120(func_004A1A60(&D_00221AD8, 4), record[2]);
+}
diff --git a/src/game/004D8A18.c b/src/game/004D8A18.c
new file mode 100644
index 000000000..cee7d272a
--- /dev/null
+++ b/src/game/004D8A18.c
@@ -0,0 +1,47 @@
+#include "common.h"
+typedef struct {
+    s32 f0, f4;
+    void *data;
+    char tail[12];
+} Item;
+typedef struct {
+    char pad[0x34];
+    Item *items;
+    char tail[0x18];
+    s32 count, index;
+} List;
+typedef struct {
+    s32 f0, f4;
+    s32 flags;
+    s32 handle;
+    char pad[0x330];
+    List list;
+    char tail[0x14];
+} State;
+extern State D_00320178[];
+extern s32 D_00221B28;
+extern char D_001CE1E8[];
+extern s32 func_00505B20(void), func_00499CA0(void *, s32), func_004A1A60(s32 *, s32), func_00506120(s32, u32);
+extern void func_00499CE0(s32);
+static inline Item *selected(List *l)
+{
+    if (l->index < 0)
+        return 0;
+    return l->items + l->index;
+}
+void func_004D8A18(void)
+{
+    State *p = D_00320178 + func_00505B20();
+    List *l = &p->list;
+    if (l->count > 0) {
+        Item *item;
+        if (p->handle) {
+            func_00499CE0(p->handle);
+            p->handle = 0;
+        }
+        item = selected(l);
+        p->handle = func_00499CA0(D_001CE1E8 + (*(s32 *)item->data) * 8, -1);
+        func_00506120(func_004A1A60(&D_00221B28, 4), p->handle);
+    }
+    p->flags &= ~2;
+}
diff --git a/src/game/004D9048.c b/src/game/004D9048.c
new file mode 100644
index 000000000..8b0290b9e
--- /dev/null
+++ b/src/game/004D9048.c
@@ -0,0 +1,61 @@
+#include "common.h"
+
+typedef struct State {
+    u8 prefix[0x10];
+    u32 first;
+    u32 second;
+} State;
+
+extern u8 D_00321140[];
+extern char D_00321110[];
+extern const char D_0021FC48[];
+extern u8 D_001CDAB8[];
+extern s32 D_00221B48;
+extern s32 func_00505B20(void);
+extern s32 func_00501638(s32 *, s32 templateId, s32 context);
+extern s32 func_00505B70(s32 type, s32 group);
+extern const char *func_0045E038(s32 id);
+extern s32 func_0011D920(char *destination, const char *format, ...);
+extern s32 func_004A1A60(s32 *group, s32 index);
+extern s32 func_00505238(s32 handle, const char *text);
+extern u32 func_00499CA0(void *descriptor, s32 sector);
+extern s32 func_005054F8(s32 handle, u32 value);
+extern s32 func_00506120(u32 handle, u32 resource);
+extern s32 func_005061D8(u32 handle, s32 a, s32 b, s32 c, s32 d,
+                         s32 e, s32 f, s32 g, s32 h);
+extern s32 func_00505040(u32 handle, s32 enabled);
+extern s32 func_00506408(u32 handle, s32 angle, s32 steps, f32 rate);
+
+void func_004D9048(void)
+{
+    s32 context = func_00505B20();
+    State *state = (State *)((u32)D_00321140 + (u32)context * 0x114u);
+    char *destination;
+    const char *format;
+    const char *first;
+    const char *second;
+    s32 handle;
+    u32 descriptor;
+
+    func_00501638(&D_00221B48, 0x34, -1);
+    func_00505B70(15, D_00221B48);
+    destination = D_00321110;
+    format = D_0021FC48;
+    first = func_0045E038(0x3265);
+    second = func_0045E038(0x2350);
+    func_0011D920(destination, format, first, second);
+    func_00505238(func_004A1A60(&D_00221B48, 8), destination);
+    handle = func_004A1A60(&D_00221B48, 7);
+    func_00505238(handle, func_0045E038(0x3264));
+    descriptor = (u32)D_001CDAB8;
+    state->first = func_00499CA0((void *)descriptor, -1);
+    func_005054F8(func_004A1A60(&D_00221B48, 1), 1);
+    func_00506120(func_004A1A60(&D_00221B48, 1), state->first);
+    state->second = func_00499CA0((void *)(descriptor + 0x6F0u), -1);
+    func_005054F8(func_004A1A60(&D_00221B48, 0), 1);
+    func_00506120(func_004A1A60(&D_00221B48, 0), state->second);
+    func_005054F8(func_004A1A60(&D_00221B48, 2), 1);
+    func_005061D8(func_004A1A60(&D_00221B48, 6), 1, 1, 1, 0, 0, 0, 0, 0);
+    func_00505040(func_004A1A60(&D_00221B48, 6), 1);
+    func_00506408(func_004A1A60(&D_00221B48, 6), 360, 10, 0.00031f);
+}
diff --git a/src/game/004D9408.c b/src/game/004D9408.c
new file mode 100644
index 000000000..491472eb2
--- /dev/null
+++ b/src/game/004D9408.c
@@ -0,0 +1,52 @@
+#include "common.h"
+typedef struct Data {
+    const char *label;
+    s32 icon;
+} Data;
+typedef struct Item {
+    u8 pad[8];
+    Data *data;
+    u8 tail[12];
+} Item;
+typedef struct List {
+    u8 pad[0x34];
+    Item *items;
+    u8 gap[0x18];
+    s32 count, index;
+} List;
+typedef struct State {
+    s32 a, b, flags, handle;
+    u8 pad[0x98];
+    List list;
+    u8 tail[0x14];
+} State;
+extern State D_00321140[];
+extern u8 D_001CE2F8[];
+extern s32 D_00221B48;
+extern s32 func_00505B20(void), func_00499CA0(const void *, s32), func_004A1A60(s32 *, s32), func_00506120(s32, s32), func_00505238(s32, const char *);
+extern void func_00499CE0(s32);
+static inline s32 count(List *l)
+{
+    return l->count;
+}
+static inline Item *selected(List *l)
+{
+    if (l->index < 0)
+        return 0;
+    return (Item *)((u32)l->items + (u32)l->index * 24);
+}
+void func_004D9408(void)
+{
+    State *p = (State *)((u32)D_00321140 + (u32)func_00505B20() * 0x114);
+    if (count(&p->list) > 0) {
+        Data *d = selected(&p->list)->data;
+        if (p->handle) {
+            func_00499CE0(p->handle);
+            p->handle = 0;
+        }
+        p->handle = func_00499CA0(D_001CE2F8 + d->icon * 8, -1);
+        func_00506120(func_004A1A60(&D_00221B48, 2), p->handle);
+        func_00505238(func_004A1A60(&D_00221B48, 6), d->label);
+    }
+    p->flags &= ~2;
+}
diff --git a/src/game/004DA2D8.c b/src/game/004DA2D8.c
new file mode 100644
index 000000000..0140aee93
--- /dev/null
+++ b/src/game/004DA2D8.c
@@ -0,0 +1,85 @@
+#include "common.h"
+
+typedef struct Item {
+    s32 kind;
+    s32 id;
+    s32 cost;
+    s32 unknownC;
+    s32 unknown10;
+    s32 label;
+    s32 unknown18;
+    s32 unknown1C;
+    s32 enabled;
+} Item;
+typedef struct Row {
+    s32 unknown;
+    s32 group;
+    Item *item;
+} Row;
+typedef struct List {
+    u8 pad00[0x54];
+    s32 selected;
+} List;
+
+extern char D_00321BA4[];
+extern u8 D_00322EA4[];
+extern s32 func_004A1A60(s32 *group, s32 index);
+extern s32 func_00504F68(s32 handle, s32 enabled);
+extern const char *func_0045E038(s32 label);
+extern s32 func_00505238(s32 handle, const char *text);
+extern s32 func_005054F8(s32 handle, u32 value);
+extern s32 func_004FC518(void);
+extern void func_004979A8(char *text, s32 value, s32 sign);
+extern s32 func_00505328(s32 handle, u32 color);
+
+void func_004DA2D8(List *list, Row *row, s32 index)
+{
+    Item *item = row->item;
+    s32 handle;
+    s32 *group;
+    char *text;
+
+    func_00504F68(func_004A1A60(&row->group, 6), item->kind == 0);
+    func_00504F68(func_004A1A60(&row->group, 2), item->kind != 0);
+    if (item->kind == 0) {
+        handle = func_004A1A60(&row->group, 7);
+        func_00505238(handle, func_0045E038(item->label));
+        return;
+    }
+    func_005054F8(func_004A1A60(&row->group, 4), 0x7546);
+    if (func_004FC518() >= item->cost) {
+        handle = func_004A1A60(&row->group, 3);
+        func_00505238(handle, func_0045E038(item->label));
+    } else {
+        handle = func_004A1A60(&row->group, 3);
+        func_00505238(handle, func_0045E038(0x16F));
+    }
+    if (item->cost == 0) {
+        handle = func_004A1A60(&row->group, 5);
+        group = &row->group;
+        func_00505238(handle, func_0045E038(0x30DC));
+    } else {
+        text = (char *)((u32)D_00321BA4 + (u32)index * 16u);
+        group = &row->group;
+        func_004979A8(text, item->cost, 0);
+        func_00505238(func_004A1A60(group, 5), text);
+    }
+    if (item->enabled != 0) {
+        func_00505328(func_004A1A60(group, 4), 0x80808080u);
+        func_00505328(func_004A1A60(group, 3), 0x80808080u);
+        if (item->cost == 0)
+            func_00505328(func_004A1A60(group, 5), 0x8040D0D0u);
+        else
+            func_00505328(func_004A1A60(group, 5), 0x80D0D0D0u);
+    } else {
+        func_00505328(func_004A1A60(group, 4), 0x80404040u);
+        func_00505328(func_004A1A60(group, 3), 0x80404040u);
+        func_00505328(func_004A1A60(group, 5), 0x80404080u);
+    }
+    if (list->selected == index) {
+        func_00505328(func_004A1A60(group, 4), 0x80D0D0D0u);
+        func_00505328(func_004A1A60(group, 3), 0x80D0D0D0u);
+    }
+    if (item->label == 0x30EB && *(s32 *)(D_00322EA4 + 0x94) == 0 && func_004FC518() >= item->cost)
+        func_00505328(func_004A1A60(group, 3), 0x807B00C9u);
+}
diff --git a/src/game/004DA960.c b/src/game/004DA960.c
new file mode 100644
index 000000000..30a3af8ce
--- /dev/null
+++ b/src/game/004DA960.c
@@ -0,0 +1,28 @@
+#include "common.h"
+extern char D_00321B98[];
+extern s32 func_004E21D8(s32, s32, void *);
+extern void func_004E0858(void);
+extern s32 func_004FC650(void);
+extern s32 func_00475858(f32, s32 *, s32, s32);
+extern void func_004979A8(void *, s32, s32);
+extern void func_004E19D8(s32, void *);
+extern void func_00497980(s32);
+void func_004DA960(void)
+{
+    char *p = D_00321B98;
+    if (*(u8 *)(p + 0x13BD)) {
+        *(u8 *)(p + 0x13BD) = 0;
+        func_004E21D8(30, 4, 0);
+        func_004E0858();
+    }
+    if (func_00475858(0.1f, (s32 *)(p + 0x1388), func_004FC650(), 1)) {
+        func_004979A8(p + 0x1378, *(s32 *)(p + 0x1388), 0);
+    } else {
+        func_004E19D8(30, 0);
+        if (*(u8 *)(p + 0x13BC)) {
+            func_00497980(32);
+            *(u8 *)(p + 0x13BC) = 0;
+        }
+        *(s32 *)(p + 4) &= ~4;
+    }
+}
diff --git a/src/game/004DAA78.c b/src/game/004DAA78.c
new file mode 100644
index 000000000..62bc5302b
--- /dev/null
+++ b/src/game/004DAA78.c
@@ -0,0 +1,80 @@
+#include "common.h"
+
+typedef struct Item {
+    s32 kind;
+    s32 id;
+    s32 cost;
+    s32 unknownC;
+    s32 unknown10;
+    s32 label;
+} Item;
+typedef struct Shop {
+    u8 pad00[4];
+    u32 dirty;
+    u8 pad08[0x1398];
+    s32 mode;
+    u8 pad13A4[0x14];
+    s32 selected;
+    u8 changed;
+    u8 rebuild;
+} Shop;
+typedef struct List {
+    u8 pad00[0x34];
+    u32 rows;
+    u8 pad38[0x18];
+    s32 count;
+    s32 selected;
+} List;
+extern List D_00322EA4;
+extern Shop D_00321B98;
+extern u8 D_00322F4C[];
+extern s32 D_0021EDD4;
+extern s32 D_0021EDD8;
+extern s32 func_004DAA20(s32 id);
+extern s32 func_004E7000(Item *item, s32 player, s32 mode);
+extern void func_00497980(s32 sound);
+
+void func_004DAA78(s32 accepted)
+{
+    u32 row;
+    s32 selected;
+    Item *item;
+    Shop *shop;
+    s32 *previous;
+
+    if (accepted == 0)
+        return;
+    selected = D_00322EA4.selected;
+    if (selected < 0)
+        row = 0;
+    else
+        row = D_00322EA4.rows + (u32)selected * 24u;
+    item = *(Item **)(row + 8);
+    if (func_004DAA20(item->id) == 0) {
+        D_00321B98.rebuild = 1;
+        D_00321B98.changed = 1;
+    }
+    shop = &D_00321B98;
+    func_004E7000(item, 0, shop->mode);
+    shop->dirty |= 5;
+    if (D_0021EDD4 != 0)
+        goto alternate;
+    if (D_0021EDD8 != 1)
+        goto alternate;
+    if (shop->mode == 1) {
+        previous = &shop->selected;
+        goto selectedTarget;
+    }
+alternate:
+    previous = (s32 *)D_00322F4C;
+selectedTarget:
+    if (item->id != *previous) {
+        *previous = item->id;
+        if (item->cost > 0)
+            func_00497980(0x21);
+        else
+            func_00497980(0x16);
+    } else {
+        func_00497980(4);
+    }
+}
diff --git a/src/game/004DEF78.c b/src/game/004DEF78.c
new file mode 100644
index 000000000..59562e9a7
--- /dev/null
+++ b/src/game/004DEF78.c
@@ -0,0 +1,37 @@
+/* cflags: -fno-schedule-insns */
+#include "common.h"
+
+extern u8 *D_00221E20;
+extern u8 *D_00221CF8;
+extern u8 *D_00221CF4;
+extern s32 D_0021DA34;
+extern s32 D_0021DA30;
+extern void func_00469968(void);
+extern u8 *func_004E7B88(void);
+
+void func_004DEF78(void)
+{
+    s32 tag;
+    u8 *packet;
+
+    D_00221CF8 = D_00221E20;
+    tag = 0x20000000;
+    D_00221E20 += 16;
+    *(s32 *)D_00221CF4 = tag;
+    packet = D_00221CF4;
+    *(u8 **)(packet + 4) = D_00221E20;
+    *(s32 *)(D_00221CF4 + 8) = 0;
+    *(s32 *)(D_00221CF4 + 12) = 0;
+    func_00469968();
+    func_004E7B88();
+    *(s32 *)D_00221E20 = tag;
+    *(u8 **)(D_00221E20 + 4) = D_00221CF4 + 16;
+    *(s32 *)(D_00221E20 + 8) = 0;
+    *(s32 *)(D_00221E20 + 12) = 0;
+    D_00221E20 += 16;
+    *(s32 *)D_00221CF8 = tag;
+    *(u8 **)(D_00221CF8 + 4) = D_00221E20;
+    *(s32 *)(D_00221CF8 + 8) = 0;
+    *(s32 *)(D_00221CF8 + 12) = 0;
+    D_0021DA30 = D_0021DA34;
+}
diff --git a/src/game/004E7990.c b/src/game/004E7990.c
new file mode 100644
index 000000000..cb9051cfe
--- /dev/null
+++ b/src/game/004E7990.c
@@ -0,0 +1,23 @@
+#include "common.h"
+
+s32 D_002206F8 = 0;
+extern char *D_00221E20;
+
+void func_004E7990(s32 command, u64 value, s32 unused)
+{
+    if (!D_002206F8) {
+        *(u32 *)(D_00221E20 + 0) = 0x10000002u;
+        *(u32 *)(D_00221E20 + 4) = 0;
+        *(u32 *)(D_00221E20 + 8) = 0;
+        *(u32 *)(D_00221E20 + 12) = 0x50000002u;
+        *(u32 *)(D_00221E20 + 16) = 0x8001;
+        *(u32 *)(D_00221E20 + 20) = 0x10000000;
+        *(u32 *)(D_00221E20 + 24) = 14;
+        *(u32 *)(D_00221E20 + 28) = 0;
+        D_00221E20 += 32;
+    }
+    *(u64 *)D_00221E20 = value;
+    *(s32 *)(D_00221E20 + 8) = command;
+    *(u32 *)(D_00221E20 + 12) = 0;
+    D_00221E20 += 16;
+}
diff --git a/src/game/004EE150.c b/src/game/004EE150.c
new file mode 100644
index 000000000..b9e26551d
--- /dev/null
+++ b/src/game/004EE150.c
@@ -0,0 +1,35 @@
+#include "common.h"
+
+extern s32 D_003284A0[][4];
+extern s32 D_0021EDD4;
+
+s32 *func_0046D428(s32 arg0, s32 arg1, s32 arg2);
+
+void func_004EE150(void)
+{
+    s32 i;
+    s32 j;
+    s32 object;
+    s32 *entry;
+
+    for (i = 0; i < 10; i++) {
+        for (j = 0; j < 4; j++) {
+            object = D_003284A0[i][j];
+            if (object != 0) {
+                *(s32 *)(object + 0x98) = 0;
+            }
+        }
+    }
+    if (D_0021EDD4 == 0) {
+        entry = func_0046D428(0x263B, 0, 0xC);
+        if (entry != 0 && entry[1] != 0) {
+            ((void (*)(void))entry[1])();
+        }
+    }
+    if (D_0021EDD4 == 1) {
+        entry = func_0046D428(0x265B, 0, 0x14);
+        if (entry != 0 && entry[4] != 0) {
+            ((void (*)(s32))entry[4])(-1);
+        }
+    }
+}
diff --git a/src/game/004F0660.c b/src/game/004F0660.c
new file mode 100644
index 000000000..3b4a15014
--- /dev/null
+++ b/src/game/004F0660.c
@@ -0,0 +1,39 @@
+#include "common.h"
+
+typedef struct Stream Stream;
+typedef struct {
+    u8 prefix[8];
+    u8 *source;
+    s32 size;
+    u64 first, second;
+} Block;
+extern Stream *D_00221ED4;
+extern char D_003D31D0[];
+extern void func_004F1C10(Stream *, u8 **, s32 *, u8 **, s32 *);
+extern s32 func_004F0848(u8 *, s32, u8 *, s32, const u8 *, s32, const u8 *, s32);
+extern s32 func_004F1CB8(Stream *, u64, u64, const u8 *, s32);
+extern void func_004EF6A0(const char *);
+extern void func_004F1C30(Stream *, s32);
+s32 func_004F0660(s32 unused, Block *block, const u8 *buffer)
+{
+    u8 *first, *second;
+    s32 firstSize, secondSize;
+    s32 offset = *(const s32 *)(buffer + 0x50008);
+    const u8 *source = block->source;
+    s32 size = block->size;
+    s32 count = (s32)((u32)buffer + offset - (u32)source);
+    s32 remaining;
+    s32 copied;
+    if (size < count)
+        count = size;
+    remaining = size - count;
+    func_004F1C10(D_00221ED4, &first, &firstSize, &second, &secondSize);
+    copied = func_004F0848((u8 *)(((u32)first & 0x0FFFFFFF) | 0x20000000), firstSize,
+                           (u8 *)(((u32)second & 0x0FFFFFFF) | 0x20000000), secondSize, source, count, buffer, remaining);
+    if (copied > 0) {
+        if (!func_004F1CB8(D_00221ED4, block->first, block->second, first, copied))
+            func_004EF6A0(D_003D31D0);
+    }
+    func_004F1C30(D_00221ED4, copied);
+    return copied > 0;
+}
diff --git a/src/game/004F1D20.c b/src/game/004F1D20.c
new file mode 100644
index 000000000..c8272caa1
--- /dev/null
+++ b/src/game/004F1D20.c
@@ -0,0 +1,35 @@
+#include "common.h"
+
+typedef struct Stream {
+    u8 prefix[0x48];
+    u8 ring[0x60];
+    s32 state;
+} Stream;
+typedef struct {
+    u8 bytes[4];
+} Command;
+extern Command D_00220918[];
+extern Stream *D_00221ED4;
+extern void func_004F1C10(Stream *, u8 **, s32 *, u8 **, s32 *);
+extern s32 func_004F2138(u8 *, s32, u8 *, s32, const void *, s32, const void *, s32);
+extern void func_004F1C30(Stream *, s32);
+extern void func_004F16C0(void *);
+s32 func_004F1D20(Stream *stream)
+{
+    Command command = D_00220918[0];
+    u8 *first;
+    s32 firstSize;
+    u8 *second;
+    s32 secondSize;
+    s32 copied;
+    func_004F1C10(stream, &first, &firstSize, &second, &secondSize);
+    if (firstSize + secondSize < 4)
+        return 0;
+    copied = func_004F2138((u8 *)(((u32)first & 0x0FFFFFFF) | 0x20000000), firstSize,
+                           (u8 *)(((u32)second & 0x0FFFFFFF) | 0x20000000), secondSize, &command, 4, 0, 0);
+    func_004F1C30(D_00221ED4, copied);
+    func_004F16C0(stream->ring);
+    if (stream->state == 0)
+        stream->state = 2;
+    return 1;
+}
diff --git a/src/game/004F1EA0.c b/src/game/004F1EA0.c
new file mode 100644
index 000000000..7e1fe49e6
--- /dev/null
+++ b/src/game/004F1EA0.c
@@ -0,0 +1,60 @@
+#include "common.h"
+
+typedef struct Video {
+    u8 *pixels;
+    u8 *packets;
+    u8 p8[8];
+    s32 count;
+} Video;
+extern Video *D_00221EA8;
+extern const char D_003D3248[], D_003D3230[];
+extern void func_004EF3E0(void);
+extern void *func_004F2360(Video *);
+extern s32 func_00142150(void *, const void *, u32);
+extern void func_004EF6A0(const char *);
+extern void func_004F0228(void *, u32, s32, s32, s32);
+extern void func_004F22F0(Video *);
+extern s32 func_00142220(void *);
+extern s32 func_004F1CA0(void *);
+extern s32 func_0011D5D8(const char *, ...);
+extern s32 func_001421A0(void *);
+s32 func_004F1EA0(void *task)
+{
+    s32 result = 1;
+    void *block;
+    s32 i;
+    s32 width, height;
+    Video *current;
+    while (!func_00142220(task)) {
+        if (func_004F1CA0(task) == 1) {
+            result = -1;
+            func_0011D5D8(D_003D3230);
+            break;
+        }
+        while ((block = func_004F2360(D_00221EA8)) == NULL) {
+            func_004EF3E0();
+        }
+        if (func_00142150(task, block, 0x340) < 0)
+            func_004EF6A0(D_003D3248);
+        if (*(s32 *)((u32)task + 8) == 0) {
+            width = *(s32 *)task;
+            height = *(s32 *)((u32)task + 4);
+            i = 0;
+            current = D_00221EA8;
+            if (i < current->count) {
+                do {
+                    func_004F0228(current->packets + (u32)i * 0x27E40 + 0x40,
+                                  (u32)current->pixels + (u32)i * 0xD0000, 0, width, height);
+                    func_004F0228(D_00221EA8->packets + (u32)i * 0x27E40 + 0x13F40,
+                                  (u32)D_00221EA8->pixels + (u32)i * 0xD0000, 1, width, height);
+                    ++i;
+                    current = D_00221EA8;
+                } while (i < current->count);
+            }
+        }
+        func_004F22F0(D_00221EA8);
+        func_004EF3E0();
+    }
+    func_001421A0(task);
+    return result;
+}
diff --git a/src/game/004F5350.c b/src/game/004F5350.c
new file mode 100644
index 000000000..9a97f6dea
--- /dev/null
+++ b/src/game/004F5350.c
@@ -0,0 +1,24 @@
+#include "common.h"
+int D_00220980 = 0;
+typedef struct Type1 {
+    char p[7];
+    unsigned char f7;
+} Type1;
+extern Type1 D_00206948[];
+extern int D_0021DDB4;
+extern void func_004F53C0(void);
+extern void func_004F5418(void);
+
+void func_004F5350(void)
+{
+    if (D_00220980) {
+        D_00206948[0].f7 = 0;
+        if (D_00220980 < 25)
+            func_004F53C0();
+        else
+            func_004F5418();
+        D_00206948[0].f7 = 1;
+        D_0021DDB4 = 6;
+        D_00220980 = 0;
+    }
+}
diff --git a/src/game/004F7FD8.c b/src/game/004F7FD8.c
new file mode 100644
index 000000000..3f019ad6d
--- /dev/null
+++ b/src/game/004F7FD8.c
@@ -0,0 +1,49 @@
+#include "common.h"
+typedef struct State {
+    u8 pad0[0x50];
+    s32 count;
+    u8 pad54[3];
+    u8 enabled;
+    u8 pad58[10];
+    s8 mode;
+} State;
+extern u8 D_003DC090[];
+u8 *D_002209F8 = D_003DC090;
+extern u64 D_0020C6C0[];
+extern s32 D_0021DF0C, D_0021DF18, D_0021DECC;
+extern s32 D_00221F74;
+extern void func_004F7A98(u64 **, s32, s32);
+extern void func_004F7A48(u64 **, s32, s32);
+void func_004F7FD8(void)
+{
+    u64 *begin = D_0020C6C0;
+    u64 *cursor = begin;
+    s32 i;
+    if (!D_002209F8[0x57] && *(s8 *)(D_002209F8 + 0x62) == -1) {
+        D_0021DECC = 0;
+        D_00221F74 = D_0021DF0C;
+        return;
+    }
+    *cursor++ = 0x1000000000000005ULL;
+    *cursor++ = 0xE;
+    *cursor++ = 0;
+    *cursor++ = 0x3F;
+    *cursor++ = 0xA0000000A0ULL;
+    *cursor++ = 0x19;
+    *cursor++ = 0x100000000ULL;
+    *cursor++ = 0x4F;
+    *cursor++ = 0x60;
+    *cursor++ = 0x15;
+    *cursor++ = 5;
+    *cursor++ = 9;
+    *(s32 *)(D_002209F8 + 0x50) = *(s32 *)(D_002209F8 + 0x50) < 5 ? *(s32 *)(D_002209F8 + 0x50) : 4;
+    if (*(s32 *)(D_002209F8 + 0x50) == 4) {
+        func_004F7A98(&cursor, D_0021DF0C, D_0021DF18);
+        D_00221F74 = D_0021DF18;
+    } else {
+        for (i = 0; i < *(s32 *)(D_002209F8 + 0x50); ++i)
+            func_004F7A48(&cursor, D_0021DF0C, D_0021DF18);
+        D_00221F74 = D_0021DF0C;
+    }
+    D_0021DECC = (s32)((u32)cursor - (u32)begin);
+}
diff --git a/src/game/004FAAA8.c b/src/game/004FAAA8.c
new file mode 100644
index 000000000..05804073e
--- /dev/null
+++ b/src/game/004FAAA8.c
@@ -0,0 +1,19 @@
+#include "common.h"
+extern s32 D_0021DF28;
+extern u32 *D_00221E20;
+extern u8 D_0020F400[];
+extern s32 D_00221F70, D_00221F80, D_0021DEF0;
+s32 D_002209D0 = 128;
+s32 D_002209BC = 0;
+extern void func_004F8778(s32, s32, s32, s32, s32, s32, u32, u32);
+void func_004FAAA8(void)
+{
+    D_00221E20[0] = (D_0021DF28 >> 4) | 0x30000000;
+    D_00221E20[1] = (u32)D_0020F400;
+    D_00221E20[2] = D_00221F70 | 0x03000000;
+    D_00221E20[3] = 0x02000000;
+    D_00221F70 += D_00221F80;
+    D_00221E20 += 4;
+    func_004F8778(D_0021DEF0, 256, 256, 1, 0, D_002209D0, 0x00808080, 0x00ffffff);
+    D_002209BC = 0;
+}
diff --git a/src/game/004FAFE8.c b/src/game/004FAFE8.c
new file mode 100644
index 000000000..da5b3dfe5
--- /dev/null
+++ b/src/game/004FAFE8.c
@@ -0,0 +1,78 @@
+#include "common.h"
+
+typedef struct {
+    char pad[0x18];
+    s32 f18;
+    s32 f1C;
+    char pad20[0xC];
+    s32 f2C;
+    s32 f30;
+    s32 f34;
+    s32 f38;
+    s32 f3C;
+    s32 f40;
+} Config;
+
+typedef struct {
+    char pad[0x10];
+    s32 f10;
+    s32 f14;
+} Bounds;
+
+extern s32 D_0021DF30[1];
+extern char *D_00221E20;
+extern char D_0020F800[];
+extern char D_00329300[];
+extern s32 D_0021DF34[1];
+extern s32 D_0021DEE4[1];
+extern s32 D_0021DEFC[1];
+extern Config D_00328A40;
+extern Bounds D_001D3F40;
+extern void func_004FAC38(void);
+extern void func_004F8B60(void);
+extern void func_004F8DF8(s32, s32);
+extern void func_004F9680(s32, s32, s32, s32, s32, s32, s32, s32, s32);
+extern void func_004F8778(s32, s32, s32, s32, s32, s32, s32, s32);
+extern void func_004E7990(s32, u64, s32);
+
+s32 D_00220A1C = 0;
+u8 D_00220A20 = 0;
+
+void func_004FAFE8(void)
+{
+    s32 x;
+    s32 y;
+    u64 mask;
+    u64 value;
+
+    func_004FAC38();
+    *(s32 *)(D_00221E20 + 0) = (D_0021DF30[0] >> 4) | 0x30000000;
+    *(s32 *)(D_00221E20 + 4) = (s32)D_0020F800;
+    *(s32 *)(D_00221E20 + 8) = 0;
+    *(s32 *)(D_00221E20 + 12) = (D_0021DF30[0] >> 4) | 0x50000000;
+    D_00221E20 += 16;
+    func_004F8B60();
+    func_004F8DF8(D_0021DF34[0], (s32)D_00329300 + (D_00220A1C << 10));
+    func_004F9680(D_0021DEE4[0], D_00328A40.f18, D_00328A40.f1C,
+                  D_00328A40.f34 << 4, D_00328A40.f38 << 4,
+                  D_00328A40.f3C << 4, D_00328A40.f40 << 4, 0xFFFF,
+                  D_0021DF34[0]);
+    func_004F8778(D_0021DEFC[0], 0x100, 0x100, 0, 1, 0x80, 0x00808080, 0xFFFF);
+    if (D_00220A20) {
+        mask = 0xFFFF00000000ULL;
+        func_004E7990(0x47, 0x70000, 0);
+        func_004E7990(1, 0x3F80000080808080ULL, 0);
+        func_004E7990(0x42, 0x8000000098ULL, 0);
+        func_004E7990(0x42, 0x8000000098ULL, 0);
+        func_004E7990(0, 0x146, 0);
+
+        y = (D_00328A40.f2C << 4) + D_001D3F40.f10 - 8;
+        x = (D_00328A40.f30 << 4) + D_001D3F40.f14 - 8;
+        value = D_001D3F40.f10 - 8;
+        value |= (u64)(D_001D3F40.f14 - 8) << 16;
+        value |= mask;
+        func_004E7990(5, value, 0);
+        value = ((u64)(s64)x << 16) | y | mask;
+        func_004E7990(5, value, 0);
+    }
+}
diff --git a/src/game/004FC310.c b/src/game/004FC310.c
new file mode 100644
index 000000000..62ee36f61
--- /dev/null
+++ b/src/game/004FC310.c
@@ -0,0 +1,30 @@
+#include "common.h"
+typedef struct {
+    u8 pad00[0xC];
+    s32 first, second;
+    u8 pad14[8];
+    s32 third, fourth, percentage;
+} Record;
+typedef struct {
+    s32 first, second, third, percentage, fourth;
+    u8 enabled;
+} Output;
+extern s32 func_0054AB40(s32 item, s32 index);
+extern const Record *func_0054A9B0(s32 record);
+extern u8 D_00171BA8[];
+
+void func_004FC310(s32 item, s32 index, Output *output)
+{
+    const Record *record;
+    s32 group;
+    if (index < 30)
+        index = (s32)((u32)(((s32)((u32)item - 1) % 20) * 30) + (u32)index);
+    record = func_0054A9B0(func_0054AB40(item, index));
+    group = (s32)((u32)item - 1) % 20;
+    output->first = record->first;
+    output->second = record->second;
+    output->third = record->third;
+    output->percentage = (s32)((f32)record->percentage * 0.01f) * 100;
+    output->fourth = record->fourth;
+    output->enabled = (*(s32 *)((u32)D_00171BA8 + ((u32)group << 2)) >> ((u32)index - (u32)(group * 30))) & 1;
+}
diff --git a/src/game/004FEF80.c b/src/game/004FEF80.c
new file mode 100644
index 000000000..c0640e907
--- /dev/null
+++ b/src/game/004FEF80.c
@@ -0,0 +1,60 @@
+#include "common.h"
+
+typedef struct A_004FEF80 {
+    s32 unk0;
+    u8 pad4[0x8 - 0x4];
+    void *unk8;
+    s32 unkC;
+    s32 unk10;
+    struct B_004FEF80 *unk14;
+    u8 unk18[0x18];
+    u8 unk30[0x18];
+    u8 unk48[0x18];
+    u8 pad60[0x64 - 0x60];
+    s32 unk64;
+} A_004FEF80;
+
+typedef struct B_004FEF80 {
+    u8 pad0[0x38];
+    s32 unk38;
+} B_004FEF80;
+
+extern u8 D_003D3548[];
+extern void func_00453608(void *, s32, s32);
+extern u8 *func_004FEE70(A_004FEF80 *, u8 *);
+extern s32 func_00501598(A_004FEF80 *);
+extern s32 func_00502440(u8 *);
+extern u8 *func_00502848(s32, s32);
+
+A_004FEF80 *func_004FEF80(A_004FEF80 *arg0, s32 arg1, B_004FEF80 *arg2) {
+    s32 id;
+    u8 *data;
+    u8 *p;
+    s32 n;
+    s32 i;
+
+    func_00501598(arg0);
+    arg0->unkC = 0;
+    arg0->unk10 = 0;
+    arg0->unk64 = 0;
+    arg0->unk14 = arg2;
+    arg0->unk8 = D_003D3548;
+    func_00453608(arg0->unk18, 0, 0x18);
+    func_00453608(arg0->unk30, 0xFF, 0x18);
+    func_00453608(arg0->unk48, 0, 0x18);
+    id = arg2->unk38;
+    if (arg2 != NULL && id >= 0 && (data = func_00502848(arg1, id)) != NULL) {
+        i = 0;
+        p = data;
+        n = func_00502440(p);
+        p += 4;
+        for (; p != NULL && i < n; i++) {
+            p = func_004FEE70(arg0, p);
+        }
+        arg0->unk0 = 1;
+    } else {
+        arg0->unk14 = NULL;
+        arg0->unk0 = 0;
+    }
+    return arg0;
+}
diff --git a/src/game/00502510.c b/src/game/00502510.c
new file mode 100644
index 000000000..59bc730f8
--- /dev/null
+++ b/src/game/00502510.c
@@ -0,0 +1,70 @@
+#include "common.h"
+
+extern const u8 *func_00502478(const u8 *stream, u32 limit);
+extern u32 func_00502448(const u8 *stream);
+extern u32 func_00502440(const u8 *stream);
+extern f32 func_00502450(const u8 *stream);
+extern s32 func_00506B70(u32 handle);
+extern s32 func_00503920(u32 handle, u32 color);
+extern s32 func_00504D68(u32 handle, u32 mask, u32 value);
+extern s32 func_00504F68(u32 handle, s32 visible);
+extern void func_00505B70(s32 type, u32 handle);
+extern s32 func_00505DD0(s32 parent, u32 child);
+extern s32 func_00504238(u32 handle, f32 x, f32 y);
+extern s32 func_005058E0(u32 handle, f32 x, f32 y);
+extern const u8 *func_00503708(const u8 *stream, s32 stopAtMarker, u32 root,
+                               u32 base, u32 parent, u32 flags, s32 attach);
+extern const u8 *func_005033D0(const u8 *stream, u32 base, u32 parent, u32 flags);
+
+const u8 *func_00502510(const u8 *stream, s32 root, u32 base, u32 parent, u32 flags, s32 attach)
+{
+    u32 mask;
+    u32 handle;
+    f32 x, y, width, height;
+    u32 color;
+    s32 visible;
+    s32 bit;
+
+    if (flags & 1) {
+        stream = func_00502478(stream, 0x1000);
+        stream = func_00502478(stream, 0x1000);
+    }
+    mask = func_00502448(stream);
+    stream += 4;
+    handle = func_00502448(stream) + base;
+    stream += 4;
+    x = func_00502450(stream);
+    stream += 4;
+    y = func_00502450(stream);
+    stream += 4;
+    width = func_00502450(stream);
+    stream += 4;
+    height = func_00502450(stream);
+    stream += 4;
+    color = func_00502440(stream);
+    stream += 4;
+    visible = func_00502448(stream) != 0;
+    stream += 4;
+    func_00506B70(handle);
+    func_00503920(handle, color);
+    for (bit = 0; bit < 8; ++bit) {
+        u32 flag = 1u << bit;
+        func_00504D68(handle, flag, mask & flag);
+    }
+    func_00504F68(handle, visible);
+    if (attach) {
+        if (root) {
+            func_00505B70(parent, handle);
+        } else {
+            func_00505DD0(parent, handle);
+        }
+    }
+    func_00504238(handle, x, y);
+    func_005058E0(handle, width, height);
+    stream = func_00503708(stream, 0, 0, base, handle, flags, 1);
+    stream = func_005033D0(stream, base, handle, flags);
+    if (!root) {
+        stream = func_00502478(stream, 0x1000);
+    }
+    return stream;
+}
diff --git a/src/game/005040B0.c b/src/game/005040B0.c
new file mode 100644
index 000000000..7b80764e4
--- /dev/null
+++ b/src/game/005040B0.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Allocator *func_005011A8(Manager *, s32);
+extern void func_00504228(s32);
+extern s32 func_00504230(void);
+extern s32 func_004FF910(void *, u32);
+extern void *func_0015DB80(u32, void *);
+extern Object *func_0050CC98(void *);
+extern s32 func_005005A8(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00222038;
+    if (manager->table) {
+        return manager;
+    }
+    return func_005010E0();
+}
+
+s32 func_005040B0(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_00504228(0x208);
+    size = func_00504230();
+    if (entry != NULL && func_004FF910(entry, key) == 0) {
+        allocator = func_005011A8(get_manager(), 0x4);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_0050CC98(func_0015DB80(0x208, block));
+            result = func_005005A8(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_005011A8(get_manager(), 0x4);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/game/00504550.c b/src/game/00504550.c
new file mode 100644
index 000000000..d419bd369
--- /dev/null
+++ b/src/game/00504550.c
@@ -0,0 +1,52 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct Vtable {
+    void *unused[3];
+    u32 (*type)(Object *);
+    void *f10;
+    s32 (*supports)(Object *, u32);
+} Vtable;
+struct Object {
+    s32 f0, f4;
+    Vtable *vtable;
+};
+typedef struct {
+    s32 f0;
+    void *context;
+} Manager;
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, s32);
+extern u32 D_00220AB8;
+static inline Object *resolve(s32 handle)
+{
+    Manager *m;
+    Object *obj;
+    void *world;
+    if (D_00222038[0].context)
+        m = D_00222038;
+    else
+        m = func_005010E0();
+    world = 0;
+    if (m->context)
+        world = *(void **)((u32)m->context + ((u32) * (s32 *)((char *)m->context + 0x14) << 2));
+    obj = func_005005E8(world, handle);
+    if (obj && obj->vtable->supports(obj, D_00220AB8))
+        return obj;
+    return 0;
+}
+typedef s32 (*Callback)(Object *, float *, float *);
+extern char D_00335FA8[];
+extern Callback func_00507A10(void *, u32);
+s32 func_00504550(s32 handle, float *a, float *b)
+{
+    s32 result = 0;
+    Object *obj = resolve(handle);
+    if (obj) {
+        u32 type = obj->vtable->type(obj);
+        Callback callback = func_00507A10(D_00335FA8, type);
+        if (callback)
+            result = callback(obj, a, b);
+    }
+    return result;
+}
diff --git a/src/game/00504648.c b/src/game/00504648.c
new file mode 100644
index 000000000..88024f937
--- /dev/null
+++ b/src/game/00504648.c
@@ -0,0 +1,52 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct Vtable {
+    void *unused[3];
+    u32 (*type)(Object *);
+    void *f10;
+    s32 (*supports)(Object *, u32);
+} Vtable;
+struct Object {
+    s32 f0, f4;
+    Vtable *vtable;
+};
+typedef struct {
+    s32 f0;
+    void *context;
+} Manager;
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, s32);
+extern u32 D_00220AB8;
+static inline Object *resolve(s32 handle)
+{
+    Manager *m;
+    Object *obj;
+    void *world;
+    if (D_00222038[0].context)
+        m = D_00222038;
+    else
+        m = func_005010E0();
+    world = 0;
+    if (m->context)
+        world = *(void **)((u32)m->context + ((u32) * (s32 *)((char *)m->context + 0x14) << 2));
+    obj = func_005005E8(world, handle);
+    if (obj && obj->vtable->supports(obj, D_00220AB8))
+        return obj;
+    return 0;
+}
+typedef s32 (*Callback)(Object *, float *, float *);
+extern char D_00336038[];
+extern Callback func_00507A10(void *, u32);
+s32 func_00504648(s32 handle, float *a, float *b)
+{
+    s32 result = 0;
+    Object *obj = resolve(handle);
+    if (obj) {
+        u32 type = obj->vtable->type(obj);
+        Callback callback = func_00507A10(D_00336038, type);
+        if (callback)
+            result = callback(obj, a, b);
+    }
+    return result;
+}
diff --git a/src/game/00504AA8.c b/src/game/00504AA8.c
new file mode 100644
index 000000000..72050de34
--- /dev/null
+++ b/src/game/00504AA8.c
@@ -0,0 +1,61 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct {
+    char pad[0xC];
+    u32 (*getType)(Object *);
+    s32 pad10;
+    s32 (*isType)(Object *, u32);
+} VTable;
+struct Object {
+    char pad[8];
+    VTable *vtable;
+};
+
+typedef struct {
+    s32 pad;
+    char *table;
+} Manager;
+extern Manager D_00222038[];
+extern u32 D_00220AB8;
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, u32);
+typedef s32 (*Callback)(Object *, f32);
+extern Callback func_00507B70(void *, u32);
+static inline Manager *getManager(void)
+{
+    Manager *p = D_00222038;
+    if (p->table)
+        return p;
+    return func_005010E0();
+}
+static inline Object *valid(Object *p)
+{
+    if (p && p->vtable->isType(p, D_00220AB8))
+        return p;
+    return 0;
+}
+static inline Object *getTyped(u32 id)
+{
+    Manager *m = getManager();
+    char *state = m->table;
+    void *table = 0;
+    if (state)
+        table = *(void **)(state + (*(s32 *)(state + 0x14) << 2));
+    return valid(func_005005E8(table, id));
+}
+extern char D_00336718[];
+static inline Callback handler(u32 kind)
+{
+    return func_00507B70(D_00336718, kind);
+}
+s32 func_00504AA8(u32 id, f32 amount)
+{
+    s32 result = 0;
+    Object *p = getTyped(id);
+    if (p) {
+        Callback callback = handler(p->vtable->getType(p));
+        if (callback)
+            result = callback(p, amount);
+    }
+    return result;
+}
diff --git a/src/game/00504F68.c b/src/game/00504F68.c
new file mode 100644
index 000000000..22e4ff233
--- /dev/null
+++ b/src/game/00504F68.c
@@ -0,0 +1,55 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct {
+    char pad[0x14];
+    s32 (*isType)(Object *, u32);
+} VTable;
+struct Object {
+    char pad[8];
+    VTable *vtable;
+    s32 flags;
+};
+typedef struct {
+    s32 pad;
+    char *table;
+} Manager;
+extern Manager D_00222038[];
+extern u32 D_00220B50;
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, u32);
+
+static inline Manager *getManager(void)
+{
+    Manager *p = D_00222038;
+    if (p->table)
+        return p;
+    return func_005010E0();
+}
+static inline Object *valid(Object *p)
+{
+    if (p && p->vtable->isType(p, D_00220B50))
+        return p;
+    return 0;
+}
+static inline Object *getTyped(u32 id)
+{
+    Manager *m = getManager();
+    char *state = m->table;
+    void *table = 0;
+    if (state)
+        table = *(void **)(state + (*(s32 *)(state + 0x14) << 2));
+    return valid(func_005005E8(table, id));
+}
+s32 func_00504F68(u32 id, s32 enabled)
+{
+    s32 result = 0;
+    Object *p = getTyped(id);
+    if (p) {
+        result = 1;
+        if (enabled)
+            p->flags |= 0x1;
+        else
+            p->flags &= ~1;
+    }
+    return result;
+}
diff --git a/src/game/00505238.c b/src/game/00505238.c
new file mode 100644
index 000000000..ee938b8c3
--- /dev/null
+++ b/src/game/00505238.c
@@ -0,0 +1,52 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct Vtable {
+    void *unused[3];
+    u32 (*type)(Object *);
+    void *f10;
+    s32 (*supports)(Object *, u32);
+} Vtable;
+struct Object {
+    s32 f0, f4;
+    Vtable *vtable;
+};
+typedef struct {
+    s32 f0;
+    void *context;
+} Manager;
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, s32);
+extern u32 D_00220AB8;
+static inline Object *resolve(s32 handle)
+{
+    Manager *m;
+    Object *obj;
+    void *world;
+    if (D_00222038[0].context)
+        m = D_00222038;
+    else
+        m = func_005010E0();
+    world = 0;
+    if (m->context)
+        world = *(void **)((u32)m->context + ((u32) * (s32 *)((char *)m->context + 0x14) << 2));
+    obj = func_005005E8(world, handle);
+    if (obj && obj->vtable->supports(obj, D_00220AB8))
+        return obj;
+    return 0;
+}
+typedef s32 (*Callback)(Object *, u32);
+extern char D_003360C8[];
+extern Callback func_00507E90(void *, u32);
+s32 func_00505238(s32 handle, u32 value)
+{
+    s32 result = 0;
+    Object *obj = resolve(handle);
+    if (obj) {
+        u32 type = obj->vtable->type(obj);
+        Callback callback = func_00507E90(D_003360C8, type);
+        if (callback)
+            result = callback(obj, value);
+    }
+    return result;
+}
diff --git a/src/game/00505328.c b/src/game/00505328.c
new file mode 100644
index 000000000..8b2fbbee2
--- /dev/null
+++ b/src/game/00505328.c
@@ -0,0 +1,52 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct Vtable {
+    void *unused[3];
+    u32 (*type)(Object *);
+    void *f10;
+    s32 (*supports)(Object *, u32);
+} Vtable;
+struct Object {
+    s32 f0, f4;
+    Vtable *vtable;
+};
+typedef struct {
+    s32 f0;
+    void *context;
+} Manager;
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, s32);
+extern u32 D_00220AB8;
+static inline Object *resolve(s32 handle)
+{
+    Manager *m;
+    Object *obj;
+    void *world;
+    if (D_00222038[0].context)
+        m = D_00222038;
+    else
+        m = func_005010E0();
+    world = 0;
+    if (m->context)
+        world = *(void **)((u32)m->context + ((u32) * (s32 *)((char *)m->context + 0x14) << 2));
+    obj = func_005005E8(world, handle);
+    if (obj && obj->vtable->supports(obj, D_00220AB8))
+        return obj;
+    return 0;
+}
+typedef s32 (*Callback)(Object *, u32);
+extern char D_003361A0[];
+extern Callback func_00507B00(void *, u32);
+s32 func_00505328(s32 handle, u32 value)
+{
+    s32 result = 0;
+    Object *obj = resolve(handle);
+    if (obj) {
+        u32 type = obj->vtable->type(obj);
+        Callback callback = func_00507B00(D_003361A0, type);
+        if (callback)
+            result = callback(obj, value);
+    }
+    return result;
+}
diff --git a/src/game/00505F98.c b/src/game/00505F98.c
new file mode 100644
index 000000000..45783b907
--- /dev/null
+++ b/src/game/00505F98.c
@@ -0,0 +1,49 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct {
+    char pad[0x14];
+    s32 (*isType)(Object *, u32);
+} VTable;
+struct Object {
+    char pad[8];
+    VTable *vtable;
+};
+typedef struct {
+    s32 pad;
+    char *table;
+} Manager;
+extern Manager D_00222038[];
+extern u32 D_00220B54;
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, u32);
+extern s32 func_0050C7D8(Object *, u32, s32);
+static inline Manager *getManager(void)
+{
+    Manager *p = D_00222038;
+    if (p->table)
+        return p;
+    return func_005010E0();
+}
+static inline Object *valid(Object *p)
+{
+    if (p && p->vtable->isType(p, D_00220B54))
+        return p;
+    return 0;
+}
+static inline Object *getTyped(u32 id)
+{
+    Manager *m = getManager();
+    char *state = m->table;
+    void *table = 0;
+    if (state)
+        table = *(void **)(state + (*(s32 *)(state + 0x14) << 2));
+    return valid(func_005005E8(table, id));
+}
+s32 func_00505F98(u32 id, u32 child, s32 index)
+{
+    s32 result = 0;
+    Object *p = getTyped(id);
+    if (p)
+        result = func_0050C7D8(p, child, index);
+    return result;
+}
diff --git a/src/game/00506508.c b/src/game/00506508.c
new file mode 100644
index 000000000..b36b6f70e
--- /dev/null
+++ b/src/game/00506508.c
@@ -0,0 +1,51 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct {
+    char pad[0x14];
+    s32 (*isType)(Object *, u32);
+} VTable;
+struct Object {
+    char pad[8];
+    VTable *vtable;
+};
+typedef struct {
+    s32 pad;
+    char *table;
+} Manager;
+extern Manager D_00222038[];
+extern u32 D_00220B54;
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, u32);
+extern void func_0050CE20(Object *, s32, s32);
+static inline Manager *getManager(void)
+{
+    Manager *p = D_00222038;
+    if (p->table)
+        return p;
+    return func_005010E0();
+}
+static inline Object *valid(Object *p)
+{
+    if (p && p->vtable->isType(p, D_00220B54))
+        return p;
+    return 0;
+}
+static inline Object *getTyped(u32 id)
+{
+    Manager *m = getManager();
+    char *state = m->table;
+    void *table = 0;
+    if (state)
+        table = *(void **)(state + (*(s32 *)(state + 0x14) << 2));
+    return valid(func_005005E8(table, id));
+}
+s32 func_00506508(u32 id, s32 mask, s32 enabled)
+{
+    s32 result = 0;
+    Object *p = getTyped(id);
+    if (p) {
+        func_0050CE20(p, mask, enabled);
+        result = 1;
+    }
+    return result;
+}
diff --git a/src/game/005081B0.c b/src/game/005081B0.c
new file mode 100644
index 000000000..7dab7a85a
--- /dev/null
+++ b/src/game/005081B0.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern Allocator *func_005011A8(Manager *, s32);
+extern void func_00504228(s32);
+extern s32 func_00504230(void);
+extern s32 func_004FF910(void *, u32);
+extern void *func_0015DB80(u32, void *);
+extern Object *func_005105A0(void *);
+extern s32 func_005005A8(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00222038;
+    if (manager->table) {
+        return manager;
+    }
+    return func_005010E0();
+}
+
+s32 func_005081B0(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_00504228(0x50);
+    size = func_00504230();
+    if (entry != NULL && func_004FF910(entry, key) == 0) {
+        allocator = func_005011A8(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_005105A0(func_0015DB80(0x50, block));
+            result = func_005005A8(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_005011A8(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/game/0050BE90.c b/src/game/0050BE90.c
new file mode 100644
index 000000000..d617dcfac
--- /dev/null
+++ b/src/game/0050BE90.c
@@ -0,0 +1,61 @@
+#include "common.h"
+
+typedef union FloatWord {
+    u32 bits;
+    f32 value;
+} FloatWord;
+typedef struct Flags {
+    u32 active : 1, b1 : 1, mode : 2, b4 : 1, b5 : 1, b6 : 1, b7 : 1, b8 : 1, rest : 23;
+} Flags;
+typedef struct Resource {
+    u32 references, reserved;
+    const void *methods;
+    Flags flags;
+    u32 field10;
+    FloatWord x, y, width, height, unitx, unity, scale;
+    u32 color, blend;
+    s32 texture;
+    void *field3C;
+} Resource;
+extern u8 D_003D35D8[];
+extern Resource *func_00501598(Resource *resource);
+extern void func_0050C058(Resource *resource, s32 x, s32 y);
+Resource *func_0050BE90(Resource *resource)
+{
+    Flags flags;
+    func_00501598(resource);
+    flags = resource->flags;
+    flags.active = 1;
+    flags.b1 = 0;
+    flags.mode = 3;
+    flags.b5 = 0;
+    flags.b4 = 0;
+    flags.b6 = 0;
+    flags.b7 = 0;
+    resource->field10 = 0;
+    resource->x.bits = 0;
+    resource->y.bits = 0;
+    resource->width.bits = 0;
+    resource->height.bits = 0;
+    resource->unitx.bits = 0;
+    resource->unity.bits = 0;
+    resource->scale.bits = 0;
+    resource->methods = D_003D35D8;
+    resource->color = 0x80808080;
+    resource->blend = 0x80808080;
+    flags.b8 = 0;
+    resource->flags = flags;
+    func_0050C058(resource, 3, 3);
+    resource->scale.value = 1.0f;
+    resource->x.value = 0.5f;
+    resource->y.value = 0.5f;
+    resource->width.value = 1.0f;
+    resource->height.value = 1.0f;
+    resource->unitx.value = 0.00390625f;
+    resource->unity.value = 0.0048076925f;
+    resource->blend = 0x40000000;
+    resource->color = 0xFFFFFFFF;
+    resource->texture = -1;
+    resource->field3C = 0;
+    return resource;
+}
diff --git a/src/game/0050C100.c b/src/game/0050C100.c
new file mode 100644
index 000000000..045d70af1
--- /dev/null
+++ b/src/game/0050C100.c
@@ -0,0 +1,86 @@
+#include "common.h"
+
+typedef struct Object Object;
+typedef struct {
+    s32 enabled;
+    u16 kind;
+    u16 unused;
+    u32 mask;
+} Event;
+typedef struct {
+    u32 id;
+    u16 kind;
+    u8 data[6];
+} Action;
+typedef struct {
+    u32 unused;
+    u16 kind;
+    u16 unused06;
+    u32 mask;
+    Action actions[15];
+} Handler;
+typedef struct {
+    void *unused[9];
+    s32 (*fallback)(Object *, const Event *);
+} VTable;
+struct Object {
+    u32 unused00, unused04;
+    VTable *vtable;
+    u32 flags;
+    u8 pad10[0x2C];
+    const Handler **handlers;
+};
+typedef struct {
+    s32 unused;
+    void *context;
+} Manager;
+
+extern Manager D_00222038[];
+extern Manager *func_005010E0(void);
+extern s32 func_0050C090(Object *, const Event *);
+extern void *func_00500ED0(Manager *);
+extern s32 func_00503D78(void *, const Action *);
+
+static inline Manager *getManager(void)
+{
+    if (D_00222038[0].context)
+        return D_00222038;
+    return func_005010E0();
+}
+
+s32 func_0050C100(Object *object, const Event *event)
+{
+    s32 handled = 0;
+    u32 index;
+    s32 action, matches;
+    const Handler *handler;
+
+    if (!(object->flags & 2) && !event->enabled)
+        goto done;
+    handled = func_0050C090(object, event);
+    if (object->handlers) {
+        for (index = 0; *(const Handler **)((u32)object->handlers + (index << 2)); index++) {
+            handler = *(const Handler **)((u32)object->handlers + (index << 2));
+            matches = 0;
+            if (event->kind == 1) {
+                if (handler->kind == 1 && (event->mask & handler->mask))
+                    matches = 1;
+            } else if (handler->kind == event->kind) {
+                matches = 1;
+            }
+            if (matches) {
+                handled = 1;
+                for (action = 0;
+                     action < 15 && handler->actions[action].kind;
+                     action++) {
+                    func_00503D78(func_00500ED0(getManager()),
+                                  &handler->actions[action]);
+                }
+            }
+        }
+    }
+    if (!handled)
+        object->vtable->fallback(object, event);
+done:
+    return handled;
+}
diff --git a/src/game/0050C638.c b/src/game/0050C638.c
new file mode 100644
index 000000000..f66575448
--- /dev/null
+++ b/src/game/0050C638.c
@@ -0,0 +1,46 @@
+#include "common.h"
+
+typedef struct Node Node;
+
+typedef struct {
+    s32 f0;
+    u32 f4;
+} Msg;
+
+typedef struct {
+    u8 pad0[0x20];
+    s32 (*f20)(Node *, Msg *);
+    s32 (*f24)(Node *, Msg *);
+} VTable;
+
+struct Node {
+    u8 pad0[8];
+    VTable *f8;
+    u32 fC;
+    u8 pad10[0x30];
+    Node *children[106];
+    s32 f1E8;
+};
+
+extern s32 func_0050C100(Node *, Msg *);
+
+s32 func_0050C638(Node *n, Msg *m) {
+    s32 r = func_0050C100(n, m);
+    s32 i;
+    u64 flags;
+
+    if (r != 0 && !(m->f4 & 0x10000)) {
+        return r;
+    }
+    flags = n->fC;
+    if (!((flags >> 1) & 1) && m->f0 == 0) {
+        return r;
+    }
+    r = (r != 0) | (n->f8->f24(n, m) != 0);
+    if ((m->f4 & 0x10000) && m->f0 == 0) {
+        for (i = 0; i < n->f1E8; i++) {
+            r = (r != 0) | (n->children[i]->f8->f20(n->children[i], m) != 0);
+        }
+    }
+    return r;
+}
diff --git a/src/game/0050C7D8.c b/src/game/0050C7D8.c
new file mode 100644
index 000000000..fd94e750e
--- /dev/null
+++ b/src/game/0050C7D8.c
@@ -0,0 +1,64 @@
+#include "common.h"
+
+typedef struct Object Object;
+typedef struct {
+    u8 unknown0[0x14];
+    s32 (*isType)(Object *, u32);
+} VTable;
+struct Object {
+    u8 unknown0[8];
+    VTable *vtable;
+};
+typedef struct {
+    s32 unknown0;
+    char *table;
+} Manager;
+typedef struct {
+    u8 unknown0[0x1E8];
+    s32 count;
+} Container;
+
+extern Manager D_00222038[];
+u32 D_00220B50 = 1;
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, u32);
+extern s32 func_0050CAC0(Container *, u32, s32);
+
+static inline Manager *manager(void)
+{
+    Manager *p = D_00222038;
+    if (p->table)
+        return p;
+    return func_005010E0();
+}
+static inline Object *valid(Object *p)
+{
+    if (p && p->vtable->isType(p, D_00220B50))
+        return p;
+    return NULL;
+}
+static inline Object *lookup(u32 id)
+{
+    Manager *p = manager();
+    char *state = p->table;
+    void *table = NULL;
+    if (state)
+        table = *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2));
+    return valid(func_005005E8(table, id));
+}
+
+s32 func_0050C7D8(Container *container, u32 child, u32 id)
+{
+    s32 result = 0;
+    Object *p = lookup(id);
+    s32 i;
+    if (p) {
+        for (i = 0; i < (s32)((u32)container->count - 1); i++) {
+            if (p == *(Object **)((u32)container + 0x40 + ((u32)i << 2))) {
+                result = func_0050CAC0(container, child, i);
+                break;
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/game/00511060.c b/src/game/00511060.c
new file mode 100644
index 000000000..b43e008ee
--- /dev/null
+++ b/src/game/00511060.c
@@ -0,0 +1,41 @@
+#include "common.h"
+typedef struct Object {
+    u32 id;
+    u32 unknown4;
+    s32 status;
+    struct Object *next;
+} Object;
+extern u32 D_003D37C0[];
+extern Object *D_00336818[];
+extern Object *D_003367E0[];
+extern void *func_00510C58(u32 id);
+extern void *func_0053E0D8(u32 id);
+void *func_00511060(u32 id)
+{
+    u32 category;
+    u32 slot;
+    Object *object;
+    if (id == 0xFFFFFFFF) {
+        return NULL;
+    }
+    category = (id >> 24) & 15;
+    slot = id & 0xFFF;
+    if (category == 0) {
+        return func_00510C58(id);
+    }
+    if (category == 2) {
+        return func_0053E0D8(id);
+    }
+    object = (Object *)((u32)D_00336818[category] + slot * D_003D37C0[category]);
+    if (object->id == id && object->status != 2) {
+        return object;
+    }
+    object = D_003367E0[category];
+    while (object) {
+        if (object->id == id && object->status != 2) {
+            return object;
+        }
+        object = object->next;
+    }
+    return NULL;
+}
diff --git a/src/game/00512650.c b/src/game/00512650.c
new file mode 100644
index 000000000..302e109ff
--- /dev/null
+++ b/src/game/00512650.c
@@ -0,0 +1,39 @@
+#include "common.h"
+typedef struct {
+    u8 prefix[0x2314];
+    s32 mode, item;
+    u8 gap[0x33C];
+    u8 enabled;
+    u8 gap2[7];
+    u8 blocked;
+} Player;
+typedef struct {
+    u8 prefix[0x30];
+    s16 value;
+} Descriptor;
+extern Descriptor *func_00548D28(s32, s32);
+extern s32 func_00512610(Player *);
+extern s32 D_0021EDD4;
+
+s32 func_00512650(Player *player, s32 use_descriptor)
+{
+    s32 item;
+    if (use_descriptor && player->enabled && !player->blocked) {
+        item = player->mode == 2 ? player->item : -1;
+        if (item == -1)
+            return 0;
+        return func_00548D28(item, 0)->value;
+    }
+    if (func_00512610(player) && D_0021EDD4 != 1)
+        return 0x65;
+    item = player->item;
+    if (item == 5)
+        return 0x42;
+    if (item == 2)
+        return 0x40;
+    if (item == 4 || item == 10)
+        return 0x44;
+    if (item == 6 || item == 7 || item == 3 || item == 8 || item == 9 || item == 13)
+        return 0x4E;
+    return 0;
+}
diff --git a/src/game/0051A638.c b/src/game/0051A638.c
new file mode 100644
index 000000000..41c1a6582
--- /dev/null
+++ b/src/game/0051A638.c
@@ -0,0 +1,49 @@
+#include "common.h"
+typedef struct Hero Hero;
+typedef struct HeroMethods {
+    u8 unknown0[0x4C];
+    s32 (*context)(Hero *hero);
+} HeroMethods;
+extern s32 D_0021EDD4;
+extern u8 *D_0021DFF0;
+extern void func_00548FD8(void *inventory, s32 retained, s32 reset);
+extern void func_00525C58(Hero *hero);
+extern void func_004A7C50(s32 context);
+extern void func_004A7D48(s32 context);
+extern void func_00522AF8(Hero *hero, s32 item, s32 mode, s32 slot);
+extern void func_00548DF8(void *inventory, s32 item, s32 level, s32 force, s32 skip_existing);
+#define AT(type, offset) (*(type *)((u32)hero + (offset)))
+void func_0051A638(Hero *hero)
+{
+    s32 *row, *a, *b, *c, *d, *e;
+    s32 i;
+    func_00548FD8(AT(void *, 0x26E4), 1, D_0021EDD4 != 1);
+    func_00525C58(hero);
+    if (AT(u8, 0x266D)) {
+        func_004A7C50(AT(HeroMethods *, 0x14)->context(hero));
+        func_004A7D48(AT(HeroMethods *, 0x14)->context(hero));
+    }
+    e = (s32 *)((u32)hero + 0x26BC);
+    d = (s32 *)((u32)hero + 0x2674);
+    c = (s32 *)((u32)hero + 0x26A4);
+    b = (s32 *)((u32)hero + 0x268C);
+    a = (s32 *)((u32)hero + 0x24B0);
+    row = (s32 *)((u32)hero + 0x2318);
+    for (i = 5; i >= 0; i--) {
+        *row = 0;
+        *a++ = 0;
+        row += 0x14;
+        *b++ = 0;
+        *c++ = 0;
+        *d++ = 0;
+        *e++ = 0;
+    }
+    AT(u8, 0x266C) = 0;
+    if (D_0021EDD4 == 1) {
+        func_00522AF8(hero, 0x12, 0, -1);
+        func_00548DF8(AT(void *, 0x26E4), 0xE, 0, 0, 0);
+        if (*(s8 *)(D_0021DFF0 + 9) != 0 && D_0021DFF0[0x2A] == 1)
+            func_00522AF8(hero, 0xD, 0, -1);
+    }
+}
+#undef AT
diff --git a/src/game/00525CB0.c b/src/game/00525CB0.c
new file mode 100644
index 000000000..9e916a34a
--- /dev/null
+++ b/src/game/00525CB0.c
@@ -0,0 +1,55 @@
+#include "common.h"
+
+extern s32 D_0021EDD4;
+extern s8 *D_0021DFF0;
+extern u8 *D_0021DFE8;
+extern s32 D_0021DE10;
+extern s32 func_00526DC0(s32, s32);
+extern void func_00526F20(s32, s32);
+extern void func_00526FD8(s32, s32, s32);
+
+void func_00525CB0(s32 a0)
+{
+    s32 result;
+    s32 counter;
+
+    if (D_0021EDD4 != 1) {
+        return;
+    }
+    if (func_00526DC0(a0, 0) == 0) {
+        func_00526F20(a0, 0);
+        return;
+    }
+    if (func_00526DC0(a0, 2) == 0 && func_00526DC0(a0, 3) == 0) {
+        func_00526FD8(a0, 2, 3);
+        return;
+    }
+    if (func_00526DC0(a0, 1) == 0) {
+        func_00526F20(a0, 1);
+        return;
+    }
+    result = func_00526DC0(a0, 4);
+    counter = D_0021DE10;
+    if (result == 0 && D_0021DFF0[9] != 0) {
+        func_00526F20(a0, 4);
+        return;
+    }
+    counter = D_0021DE10;
+    if (counter % 10 < 6) {
+        if (func_00526DC0(a0, 5) == 0) {
+            if (D_0021DFE8[0x1A9] != 2) {
+                func_00526F20(a0, 5);
+                return;
+            }
+        }
+    }
+    if (D_0021DE10 % 10 >= 6) {
+        return;
+    }
+    if (func_00526DC0(a0, 0x14) != 0) {
+        return;
+    }
+    if (D_0021DFE8[0x1A9] != 2) {
+        func_00526F20(a0, 0x14);
+    }
+}
diff --git a/src/game/0053D6E0.c b/src/game/0053D6E0.c
new file mode 100644
index 000000000..5b7f1f29b
--- /dev/null
+++ b/src/game/0053D6E0.c
@@ -0,0 +1,30 @@
+#include "common.h"
+typedef struct {
+    s32 count;
+} Manager;
+typedef struct {
+    char pad[0x2EF8];
+    s32 *state;
+    char gap[0x1C];
+    s32 owner;
+} Object;
+extern Manager *D_0021DDA4, *D_0021DDA8;
+extern Object *func_00510BE8(s32), *func_00510C10(s32);
+void func_0053D6E0(s32 owner, s32 id)
+{
+    s32 i;
+    for (i = 0; i < D_0021DDA4->count; i++) {
+        Object *p = func_00510BE8(i);
+        if (p && p->owner == owner && p->state) {
+            if (*p->state == id)
+                p->owner = 0;
+        }
+    }
+    for (i = 0; i < D_0021DDA8->count; i++) {
+        Object *p = func_00510C10(i);
+        if (p && p->owner == owner && p->state) {
+            if (*p->state == id)
+                p->owner = 0;
+        }
+    }
+}
diff --git a/src/game/005480A8.c b/src/game/005480A8.c
new file mode 100644
index 000000000..ce6440b78
--- /dev/null
+++ b/src/game/005480A8.c
@@ -0,0 +1,29 @@
+#include "common.h"
+
+typedef struct {
+    s32 f0, value;
+    u8 rest[24];
+} __attribute__((packed)) Data;
+typedef struct {
+    f32 f0;
+    u32 f4;
+    s32 f8;
+    u32 fC;
+} Scale;
+extern const Data *func_00548D68(s32, s32);
+extern s32 func_0045CB50(void);
+extern Scale D_003DE168[];
+s32 func_005480A8(s32 kind, s32 level)
+{
+    s32 low = level < 9;
+    Data data = *func_00548D68(kind, low ? level : 8);
+    s32 value = data.value;
+    if (func_0045CB50() && !low) {
+        s32 excess = level - 8;
+        s32 triangle = excess * (level - 7) / 2;
+        f32 coefficient = *(f32 *)((u32)kind * 16 + (u32)D_003DE168);
+        s32 step = *(s32 *)((u32)D_003DE168 + (u32)kind * 16 + 8);
+        value += step * excess + (s32)(coefficient * (f32)triangle);
+    }
+    return value;
+}
diff --git a/src/game/0054A0C0.c b/src/game/0054A0C0.c
new file mode 100644
index 000000000..b06653c84
--- /dev/null
+++ b/src/game/0054A0C0.c
@@ -0,0 +1,23 @@
+#include "common.h"
+
+typedef struct {
+    u8 unknown0[0xD];
+    u8 allowed[10];
+    u8 unknown17[0x21];
+} Definition;
+
+extern const Definition *func_00549AE8(s32);
+
+s32 func_0054A0C0(s32 item, s32 mode)
+{
+    Definition definition;
+    s32 i;
+
+    definition = *func_00549AE8(mode);
+    for (i = 0; i < 10; i++) {
+        if (definition.allowed[i] == item) {
+            return 1;
+        }
+    }
+    return 0;
+}
diff --git a/src/game/0054A4A0.c b/src/game/0054A4A0.c
new file mode 100644
index 000000000..4eae2857a
--- /dev/null
+++ b/src/game/0054A4A0.c
@@ -0,0 +1,38 @@
+#include "common.h"
+
+extern void func_00549D20(void *, s32, s32, s32);
+extern s32 func_00547E30(void *, s32);
+extern s32 func_00547E00(void *, s32);
+extern void func_00547DC8(void *, s32, s32);
+
+s32 func_0054A4A0(void *arg0, s32 arg1, s32 arg2, s32 arg3)
+{
+    u8 *pointer;
+    s32 offset;
+    s32 result;
+    s32 other;
+    s32 i;
+
+    if ((u32)(arg2 - 1) >= 8) {
+        return 0;
+    }
+    offset = arg1 * 0x44;
+    pointer = (u8 *)arg0 + offset;
+    for (i = 0; i < 0xA; i++, pointer += 4) {
+        if (pointer[0xA44] == arg2) {
+            pointer[0xA44] = 0;
+            if (arg3 != 0) {
+                func_00549D20(arg0, arg2, -1, 0);
+            }
+            if (arg2 == 2) {
+                result = func_00547E30(arg0, arg1);
+                other = func_00547E00(arg0, arg1);
+                if (result < other) {
+                    func_00547DC8(arg0, arg1, result);
+                }
+            }
+            return 1;
+        }
+    }
+    return 0;
+}
diff --git a/src/pal/game/0054C250.c b/src/game/0054ACE8.c
similarity index 56%
rename from src/pal/game/0054C250.c
rename to src/game/0054ACE8.c
index 474af761c..63fac4746 100644
--- a/src/pal/game/0054C250.c
+++ b/src/game/0054ACE8.c
@@ -7,32 +7,32 @@ typedef struct {
     s32 id;
     s32 bit;
 } State;
-extern s32 func_0054C330(const State *state);
-extern s32 func_0054C100(s32 id, s32 *row);
-extern s32 D_00171BCC[];
-extern u8 D_00171C88[];
+extern s32 func_0054ADC8(const State *state);
+extern s32 func_0054AB98(s32 id, s32 *row);
+extern s32 D_00171B4C[];
+extern u8 D_00171C08[];
 typedef struct {
     u8 unknown0[9];
     u8 unlocked;
     u8 unknownA[2];
 } Record;
-extern Record D_001F8878[];
-s32 func_0054C250(State *state)
+extern Record D_001F87F0[];
+s32 func_0054ACE8(State *state)
 {
-    if (!func_0054C330(state))
+    if (!func_0054ADC8(state))
         return 0;
-    if (D_00171BCC[0] < state->time)
+    if (D_00171B4C[0] < state->time)
         return 0;
     if ((u32)state->id + 1 >= 2) {
         s32 row;
-        s32 index = func_0054C100(state->id, &row);
+        s32 index = func_0054AB98(state->id, &row);
         u32 offset = (u32)index * 12 + (u32)((s32)((u32)row - 1) % 20) * 0x304;
-        Record *record = (Record *)((u32)D_001F8878 + offset);
+        Record *record = (Record *)((u32)D_001F87F0 + offset);
         if (!record->unlocked)
             return 0;
     }
     if (state->bit != -1) {
-        u32 word = *(u32 *)((u32)D_00171C88 + (((u32)state->bit >> 5) << 2));
+        u32 word = *(u32 *)((u32)D_00171C08 + (((u32)state->bit >> 5) << 2));
         if (!(word & (1u << (state->bit & 31))))
             return 0;
     }
diff --git a/src/game/0054C250.c b/src/game/0054C250.c
new file mode 100644
index 000000000..874057ac6
--- /dev/null
+++ b/src/game/0054C250.c
@@ -0,0 +1,44 @@
+#include "common.h"
+
+extern s32 D_00355320[];
+extern void func_0054E910(void);
+extern s32 func_00453CE8(void *);
+extern void func_004F6150(f32);
+
+s32 func_0054C250(s32 arg0) {
+    s32 *record;
+    s32 result = 0;
+    s32 one = 1;
+    func_0054E910();
+    record = D_00355320;
+    switch (record[0x14 / 4]) {
+    case 0:
+        if (func_00453CE8(record + 0x10 / 4) != 0) {
+            record[0x14 / 4] = one;
+            record[0x10 / 4] = 0x1E;
+        }
+        func_004F6150(1.0f);
+        break;
+    case 1:
+        if (func_00453CE8(record + 0x10 / 4) != 0) {
+            record[0x14 / 4] = 2;
+            record[0x10 / 4] = 0x12C;
+        }
+        func_004F6150((f32)record[0x10 / 4] / 30.0f);
+        break;
+    case 2:
+        if (func_00453CE8(record + 0x10 / 4) != 0) {
+            record[0x14 / 4] = 3;
+            record[0x10 / 4] = 0x1E;
+        }
+        func_004F6150(0.0f);
+        break;
+    case 3:
+        if (arg0 != 0) {
+            result = func_00453CE8(record + 0x10 / 4) ? one : 0;
+        }
+        func_004F6150(1.0f - (f32)record[0x10 / 4] / 30.0f);
+        break;
+    }
+    return result;
+}
diff --git a/src/game/0054CC60.c b/src/game/0054CC60.c
new file mode 100644
index 000000000..97a945ee5
--- /dev/null
+++ b/src/game/0054CC60.c
@@ -0,0 +1,48 @@
+#include "common.h"
+
+f32 D_00221000 = 0.13f;
+f32 D_00220FFC = 0.125f;
+f32 D_00221008 = 60.0f;
+f32 D_0022100C = 64.0f;
+f32 D_00221010 = 64.0f;
+f32 D_00221014 = 0.0f;
+f32 D_00221018 = 15.0f;
+f32 D_00221020 = 375.0f;
+f32 D_00221024 = 60.0f;
+u64 D_00221028 = 0xFFFFFFFF803C3C3CULL;
+
+extern f32 D_0022210C;
+extern s32 D_001D3F40[];
+extern const s32 D_003D4E38[];
+extern const s32 D_003D4E58[];
+
+extern void *memcpy(void *, const void *, u32);
+extern void func_004E7990(s32, u64, s32);
+extern s32 func_00448F98(s32, s32);
+extern void func_0044A238(s32, s32, s32, s32, u64, s32, f32, f32, f32, f32);
+
+void func_0054CC60(void)
+{
+    u64 color = D_00221028;
+    s32 first[8];
+    s32 second[8];
+    s32 i;
+
+    func_004E7990(0x42, 0x8000000044ULL, 0);
+    func_004E7990(0x47, 0x3004B, 0);
+    D_0022100C = D_00220FFC * (f32)D_001D3F40[0];
+    D_00221010 = D_00220FFC * (f32)D_001D3F40[1];
+    D_0022210C = D_00221000 * (f32)D_001D3F40[0] * 0.96f;
+    memcpy(first, D_003D4E38, sizeof(first));
+    for (i = 0; i < 8; i++) {
+        D_00221014 = (f32)i * D_0022100C;
+        func_0044A238(0, 0, 0x40, 0x40, color, func_00448F98(first[i], 1),
+                      D_00221014, D_00221018, D_0022210C, D_00221024);
+    }
+    memcpy(second, D_003D4E58, sizeof(second));
+    for (i = 0; i < 8; i++) {
+        D_00221014 = (f32)i * D_0022100C;
+        func_0044A238(0, 0, 0x40, 0x40, color, func_00448F98(second[i], 1),
+                      D_00221014, D_00221020, D_0022210C, D_00221008);
+    }
+}
diff --git a/src/pal/net/01EA4570.c b/src/net/01EA4570.c
similarity index 70%
rename from src/pal/net/01EA4570.c
rename to src/net/01EA4570.c
index 36cfd3b76..2d9afb868 100644
--- a/src/pal/net/01EA4570.c
+++ b/src/net/01EA4570.c
@@ -1,10 +1,10 @@
 /* cflags: -O2 -G8 -mno-split-addresses -malign-jumps=3 */
 #include "common.h"
 
-extern s32 D_001AF998[];
+extern s32 D_001AF918[];
 
 s32 func_01EA4570(u32 index) {
     u32 byte_offset = index * sizeof(s32);
     if (index >= 4) return 0;
-    return *(s32 *)((u8 *)D_001AF998 + byte_offset);
+    return *(s32 *)((u8 *)D_001AF918 + byte_offset);
 }
diff --git a/src/net/01EAEBE0.c b/src/net/01EAEBE0.c
new file mode 100644
index 000000000..4f5dfdb51
--- /dev/null
+++ b/src/net/01EAEBE0.c
@@ -0,0 +1,36 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+extern void func_0011A518(void *, s32, s32);
+extern void func_01EAED20(u8 *);
+extern void func_01EB0C70(u8 *, s32, s32);
+extern void func_01EB0CA0(u8 *, u8 *, u32);
+
+void func_01EAEBE0(u8 *ctx, u8 *out, u32 len) {
+    s32 n;
+    u8 *p;
+
+    n = *(s32 *)(ctx + 0x58);
+    n = (n >> 3) & 0x3F;
+    p = ctx + n;
+    n = 0x3F - n;
+    *p++ = 0x80;
+    if (n < 8) {
+        func_0011A518(p, 0, n);
+        func_01EB0C70(ctx, 0x40, *(s32 *)(ctx + 0x54));
+        func_01EAED20(ctx);
+        func_0011A518(ctx, 0, 0x38);
+    } else {
+        func_0011A518(p, 0, n - 8);
+    }
+    *(s32 *)(ctx + 0x38) = *(s32 *)(ctx + 0x5C);
+    *(s32 *)(ctx + 0x3C) = *(s32 *)(ctx + 0x58);
+    func_01EB0C70(ctx, 0x38, *(s32 *)(ctx + 0x54));
+    func_01EAED20(ctx);
+    if (len > 0x14) {
+        func_0011A518(out + 0x14, 0, len - 0x14);
+        len = 0x14;
+    }
+    func_01EB0CA0(out, ctx + 0x40, len);
+    *(s32 *)ctx = 0;
+}
diff --git a/src/net/01EB36A0.c b/src/net/01EB36A0.c
new file mode 100644
index 000000000..b829ca5c1
--- /dev/null
+++ b/src/net/01EB36A0.c
@@ -0,0 +1,52 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+typedef struct N_01EB36A0 {
+    u8 pad0[0x8];
+    s32 unk8;
+    u8 padC[0x14 - 0xC];
+    s32 unk14;
+    s32 unk18;
+    s32 unk1C;
+} N_01EB36A0;
+
+extern void func_0011A370(s32, s32, s32);
+extern s32 func_01EA90F0(s32);
+extern void func_01EA94D0(s32 *, s32);
+extern void func_01EAE2C0(s32, s32);
+extern s32 func_01EB2EE0(s32);
+extern N_01EB36A0 *func_01EB2F20(void);
+extern void func_01EB2FF0(s32, N_01EB36A0 *);
+extern N_01EB36A0 *func_01EB3028(s32, s32);
+
+s32 func_01EB36A0(s32 arg0, s32 arg1, s32 arg2) {
+    s32 ctx;
+    N_01EB36A0 *n;
+
+    ctx = func_01EA90F0(arg0);
+    if (ctx == 0) {
+        return -1;
+    }
+    if (func_01EB2EE0(arg2) != 0) {
+        return -1;
+    }
+    n = func_01EB3028(ctx, arg1);
+    if (n == NULL) {
+        n = func_01EB2F20();
+        n->unk8 = arg1;
+        func_01EB2FF0(ctx, n);
+    }
+    if (n->unk1C == 0) {
+        func_01EA94D0(&n->unk1C, 0x40);
+    }
+    if (n->unk14 == 0) {
+        func_01EA94D0(&n->unk14, 0x10C);
+    }
+    if (n->unk18 == 0) {
+        func_01EA94D0(&n->unk18, 0x10C);
+    }
+    func_0011A370(n->unk1C, arg2, 0x40);
+    func_01EAE2C0(n->unk14, arg2);
+    func_01EAE2C0(n->unk18, arg2);
+    return 0;
+}
diff --git a/src/net/01EB5FB0.c b/src/net/01EB5FB0.c
new file mode 100644
index 000000000..1b6f3d24c
--- /dev/null
+++ b/src/net/01EB5FB0.c
@@ -0,0 +1,46 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+typedef struct Pool {
+    s32 f0;
+    u32 f4;
+    u32 f8;
+    u32 fC;
+    u8 *f10;
+    u8 *f14;
+} Pool;
+
+extern void func_0011A518(void *, s32, s32);
+extern s32 func_01EA94D0(u8 **, u64);
+
+s32 func_01EB5FB0(Pool *p, u32 size, u32 elem) {
+    s32 ret;
+
+    if (p == NULL) {
+        return 2;
+    }
+    if (size & 3) {
+        return 2;
+    }
+    if (elem & 3) {
+        return 2;
+    }
+    if (elem >= size) {
+        return 2;
+    }
+    func_0011A518(p, 0, 0x18);
+    ret = func_01EA94D0(&p->f10, size);
+    if (ret != 0) {
+        return ret;
+    }
+    p->f4 = size;
+    p->f8 = elem;
+    p->f0 = 0;
+    p->fC = size / elem;
+    if (size % elem < p->fC) {
+        p->fC = p->fC - (p->fC - size % elem) / elem;
+    }
+    p->f14 = p->f10 + p->fC * p->f8;
+    func_0011A518(p->f14, 0, p->fC);
+    return 0;
+}
diff --git a/src/net/01ED66B0.c b/src/net/01ED66B0.c
new file mode 100644
index 000000000..7b242bc21
--- /dev/null
+++ b/src/net/01ED66B0.c
@@ -0,0 +1,16 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+s32 func_0011D5D8(void *);
+s32 func_01ED5DD0(s32, s32, s32, void *);
+extern s32 D_00169CD0;
+extern s32 D_00169CD4;
+extern s32 D_00198478[];
+extern s32 D_001B7878[];
+
+s32 func_01ED66B0(void) {
+    func_0011D5D8(D_00198478);
+    if (D_00169CD0 != 1) return -0xF;
+    if (D_00169CD4 == 0) return -0x10;
+    return (func_01ED5DD0(1, 0x7, 0x66, D_001B7878) == 0) ? 0 : -5;
+}
diff --git a/src/net/01EDA668.c b/src/net/01EDA668.c
new file mode 100644
index 000000000..0d6f2da62
--- /dev/null
+++ b/src/net/01EDA668.c
@@ -0,0 +1,64 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+typedef struct E_01EDA668 {
+    u16 id;
+    u8 pad2[0x8 - 0x2];
+    s32 unk8;
+    u8 padC[0x10 - 0xC];
+    s32 unk10;
+    s32 unk14;
+} E_01EDA668;
+
+typedef struct O_01EDA668 {
+    s32 unk0;
+    s16 unk4;
+    s32 unk8;
+    s32 unkC;
+} O_01EDA668;
+
+extern s32 func_01EA94D0(void *, s32);
+
+O_01EDA668 *func_01EDA668(s32 arg0, E_01EDA668 **list, u32 size) {
+    O_01EDA668 *p;
+    u32 n;
+    u16 count;
+    u16 i;
+    s32 mask;
+    E_01EDA668 *e;
+
+    mask = 0;
+    n = size >> 2;
+    count = n;
+    if (list == NULL) {
+        return NULL;
+    }
+    if (count == 0) {
+        return NULL;
+    }
+    for (i = 0; i < count; i++) {
+        e = list[i];
+        if (e == NULL) {
+            return NULL;
+        }
+        if (e->id != i) {
+            return NULL;
+        }
+        if (e->unk14 == 0) {
+            return NULL;
+        }
+        if (e->unk10 == 0) {
+            return NULL;
+        }
+        if (e->unk8 == 0) {
+            return NULL;
+        }
+        mask |= 1 << i;
+    }
+    func_01EA94D0(&p, 0x10);
+    p->unk0 = arg0;
+    p->unk8 = (s32)list;
+    p->unk4 = n;
+    p->unkC = mask;
+    return p;
+}
diff --git a/src/net/01EEE13C.c b/src/net/01EEE13C.c
new file mode 100644
index 000000000..072d97590
--- /dev/null
+++ b/src/net/01EEE13C.c
@@ -0,0 +1,22 @@
+/* cflags: -Os -G8 -mno-split-addresses -mips3 -mcpu=r4000 */
+#include "common.h"
+
+typedef struct Type1 Type1;
+struct Type1 {
+    char _p0[0x84];
+    s32 f84;
+};
+
+s32 func_01F0C090(void *, s32);
+extern Type1 *D_0016E430[];
+extern s32 D_0019C400[];
+
+s32 func_01EEE13C(void) {
+    if (D_0016E430[0] == NULL) {
+        func_01F0C090(D_0019C400, 0x6D);
+    }
+    if (D_0016E430[0]->f84 == 0) {
+        func_01F0C090(D_0019C400, 0x6E);
+    }
+    return D_0016E430[0]->f84;
+}
diff --git a/src/net/01EF2CC4.c b/src/net/01EF2CC4.c
new file mode 100644
index 000000000..ea9471613
--- /dev/null
+++ b/src/net/01EF2CC4.c
@@ -0,0 +1,17 @@
+/* cflags: @ee296 -O2 -G0 -falign-jumps=1 -mno-split-addresses */
+#include "common.h"
+
+s32 func_01EF2C94(s32);
+s32 func_01EF2DB8(s32);
+extern s32 D_0016E498[];
+
+s32 func_01EF2CC4(void) {
+    s32 temp_v0;
+
+    if (D_0016E498[0] == 0) {
+        temp_v0 = func_01EF2DB8(0x204);
+        func_01EF2C94(temp_v0);
+        D_0016E498[0] = temp_v0;
+    }
+    return D_0016E498[0];
+}
diff --git a/src/net/01EF7830.c b/src/net/01EF7830.c
new file mode 100644
index 000000000..07952d2cf
--- /dev/null
+++ b/src/net/01EF7830.c
@@ -0,0 +1,75 @@
+/* cflags: @ee296 -O2 -G0 -fno-gcse -Wa,-mips4 */
+#include "common.h"
+
+typedef struct Obj Obj;
+typedef struct ObjVt {
+    char _p0[0x20];
+    void (*f20)(Obj *, s32, s32, s32, s32, f32, f32, f32, f32, f32, s32, char *, s32, s32, s32, s32);
+} ObjVt;
+struct Obj {
+    ObjVt *vt;
+};
+
+typedef struct Self {
+    char _p0[0x4];
+    s32 f4;
+    s32 f8;
+    char _pC[0xC];
+    f32 f18;
+    f32 f1C;
+    f32 f20;
+    f32 f24;
+    f32 f28;
+    s32 f2C;
+    s32 f30;
+    char _p34[0x4C];
+    Obj **f80;
+    char _p84[0x1C];
+    s32 fA0;
+    char _pA4[0x10];
+    s32 fB4;
+    s32 fB8;
+    f32 fBC;
+    char *fC0;
+    char _pC4[0x14];
+    s32 fD8;
+    s32 fDC;
+    s32 fE0;
+    s32 fE4;
+} Self;
+
+s32 func_0011AB04(char *);
+s32 func_01EEC4E8(Obj *, char *, s32, f32);
+char *func_01EF7C5C(void);
+void func_01F06988(char *);
+
+void func_01EF7830(Self *arg0) {
+    Obj *obj;
+    s32 len;
+    s32 a;
+    s32 b;
+    s32 c;
+    char *s;
+    f32 f;
+
+    obj = *arg0->f80;
+    s = func_01EF7C5C();
+    arg0->fC0 = s;
+    func_01F06988(s);
+    len = func_0011AB04(arg0->fC0);
+    a = arg0->fD8;
+    b = arg0->f2C;
+    c = arg0->f30;
+    if (arg0->f8 != 0) {
+        a = arg0->fDC;
+        b = arg0->fE0;
+        c = arg0->fE4;
+    }
+    f = arg0->fBC;
+    if (f > 0.0f) {
+        len = func_01EEC4E8(obj, arg0->fC0, arg0->fB4, f);
+    }
+    obj->vt->f20(obj, arg0->f4, a, b, c,
+                 arg0->f18, arg0->f1C, arg0->f20, arg0->f24, arg0->f28,
+                 arg0->f8, arg0->fC0, len, arg0->fB4, arg0->fB8, arg0->fA0);
+}
diff --git a/src/net/01F047A0.c b/src/net/01F047A0.c
new file mode 100644
index 000000000..b101d3228
--- /dev/null
+++ b/src/net/01F047A0.c
@@ -0,0 +1,45 @@
+/* cflags: @ee296 -O2 -G0 -falign-jumps=1 -mno-split-addresses */
+#include "common.h"
+
+typedef struct O_01F047A0 {
+    u8 pad0[0xB8];
+    s32 unkB8;
+} O_01F047A0;
+
+extern s32 func_00121FA0(s32, char *);
+extern s32 func_01EE3A18(s32, char *);
+extern void func_01EEFB78(s32, s32);
+extern void func_01F0C090(char *, s32);
+extern char D_0019E090[];
+extern char D_0019E0A0[];
+extern char D_0019E0B0[];
+extern char D_0019E0B8[];
+extern char D_0019E0C8[];
+extern char D_0019E0D0[];
+
+s32 func_01F047A0(O_01F047A0 *arg0, s32 arg1) {
+    s32 a;
+    s32 b;
+    s32 v;
+
+    a = func_01EE3A18(arg1, D_0019E0A0);
+    b = func_01EE3A18(arg1, D_0019E0B0);
+    if (a != 0 && b != 0) {
+        func_01EEFB78(a, b);
+    } else {
+        func_01F0C090(D_0019E090, 0x6C);
+        return 0;
+    }
+    v = func_01EE3A18(arg1, D_0019E0B8);
+    if (v != 0) {
+        if (func_00121FA0(v, D_0019E0C8) == 0) {
+            arg0->unkB8 = 0;
+        } else if (func_00121FA0(v, D_0019E0D0) == 0) {
+            arg0->unkB8 = 1;
+        } else {
+            func_01F0C090(D_0019E090, 0x7F);
+            return 0;
+        }
+    }
+    return 1;
+}
diff --git a/src/net/01F07100.c b/src/net/01F07100.c
new file mode 100644
index 000000000..4563b941b
--- /dev/null
+++ b/src/net/01F07100.c
@@ -0,0 +1,17 @@
+/* cflags: @ee296 -O2 -G0 -falign-jumps=1 -mno-split-addresses */
+#include "common.h"
+
+void func_0011EAD0(void *);
+void func_01F07154(void *);
+extern s32 D_0016E654[];
+extern s32 D_001B7FA0[];
+void func_01F075D0();
+
+void *func_01F07100(void) {
+    if (D_0016E654[0] == 0) {
+        func_01F07154(D_001B7FA0);
+        D_0016E654[0] = 1;
+        func_0011EAD0(func_01F075D0);
+    }
+    return D_001B7FA0;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_004F8F78.c b/src/overlays/l00_multiplayer_menu/L00_004F8F78.c
new file mode 100644
index 000000000..cceff950d
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_004F8F78.c
@@ -0,0 +1,58 @@
+/* cflags: @ee29 */
+#include "common.h"
+
+extern u64 func_00130480(u64, u64);
+
+typedef struct HashNode {
+    union {
+        s32 i;
+        void *p;
+    } key;
+    struct HashNode *next;
+    u64 hash;
+} HashNode;
+
+typedef struct {
+    HashNode **buckets;
+    s32 (*compare)(s32, s32);
+    u64 (*hash)(s32);
+    u8 padC[0x10 - 0xC];
+    u32 size;
+    u32 minIndex;
+    u32 altSize;
+    u8 pad1C[0x58 - 0x1C];
+    u64 lookups;
+    u64 compares;
+    u8 pad68[0x98 - 0x68];
+    u64 probes;
+} HashTable;
+
+HashNode **func_L00_004F8F78(HashTable *t, s32 key, u64 *outHash) {
+    u64 h = t->hash(key);
+    u64 idx;
+    s32 (*compare)(s32, s32);
+    HashNode **pp;
+    HashNode *n;
+
+    t->lookups++;
+    *outHash = h;
+    idx = func_00130480(h, t->altSize);
+    if (idx < t->minIndex) {
+        idx = func_00130480(h, t->size);
+    }
+    compare = t->compare;
+    pp = &t->buckets[(s32)idx];
+    n = *pp;
+    while (n != NULL) {
+        t->probes++;
+        if (n->hash == h) {
+            t->compares++;
+            if (compare(n->key.i, key) == 0) {
+                break;
+            }
+        }
+        pp = &n->next;
+        n = n->next;
+    }
+    return pp;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_004FD6B8.c b/src/overlays/l00_multiplayer_menu/L00_004FD6B8.c
new file mode 100644
index 000000000..43ae0d6bc
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_004FD6B8.c
@@ -0,0 +1,27 @@
+/* cflags: @ee29 -O2 -G0 */
+#include "common.h"
+
+typedef struct H_004FD6B8 { s32 type; s32 pad4[2]; s32 unkC; } H_004FD6B8;
+typedef struct O_004FD6B8 { s32 pad0; s32 *unk4; } O_004FD6B8;
+extern H_004FD6B8 *func_L00_004F7BE0(s32);
+extern void func_L00_004F84C8(int, int, int, int, int);
+extern s32 func_L00_005266A0(s32, s32, s32, s32, s32);
+
+s32 func_L00_004FD6B8(O_004FD6B8 *arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4) {
+    s32 ret = -1;
+    H_004FD6B8 *h;
+
+    if (arg0 == NULL || *arg0->unk4 == 0 || (h = func_L00_004F7BE0(*arg0->unk4)) == NULL) {
+        func_L00_004F84C8(0x14, 0xBC, 0xC0, 0, 0);
+        return -1;
+    }
+    if (h->type != 6) {
+        func_L00_004F84C8(0x14, 0xBC, 0xD1, 0, 0);
+    } else {
+        ret = func_L00_005266A0(arg1, arg2, arg3, h->unkC, arg4);
+        if (ret < 0) {
+            func_L00_004F84C8(0x14, 0xBC, 0x804, 0, 0);
+        }
+    }
+    return ret;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00501980.c b/src/overlays/l00_multiplayer_menu/L00_00501980.c
new file mode 100644
index 000000000..f20e7ad72
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00501980.c
@@ -0,0 +1,55 @@
+/* cflags: @ee29 */
+#include "common.h"
+
+typedef struct {
+    u8 pad0[0x14];
+    s32 f14;
+    s32 f18;
+    s32 f1C;
+    s32 f20;
+    s32 f24;
+    u8 pad28[0x10];
+    s32 f38;
+} Buf;
+
+typedef struct {
+    u8 pad0[0x10];
+    s32 f10;
+    u8 pad14[4];
+    s32 f18;
+    u8 pad1C[0x34];
+    s32 f50;
+} Conn;
+
+extern s32 *func_0011A1A0(void);
+extern void func_L00_004F84C8(s32, s32, s32, s32, s32);
+extern s32 func_L00_00516AB0(s32, s32, s32);
+
+s32 func_L00_00501980(Conn *arg0, s32 arg1, s32 arg2) {
+    s32 n;
+
+    if (arg2 < ((Buf *)arg0->f50)->f14 || ((Buf *)arg0->f50)->f18 != arg1) {
+        func_L00_004F84C8(0x14, 0xD5, 0x7F, 0, 0);
+        return -1;
+    }
+    while (1) {
+        *func_0011A1A0() = 0;
+        if (arg0->f10 != 0) {
+            arg0->f18 = 2;
+            n = func_L00_00516AB0(arg0->f10, ((Buf *)arg0->f50)->f38 + ((Buf *)arg0->f50)->f1C, ((Buf *)arg0->f50)->f20);
+        } else {
+            func_L00_004F84C8(0x14, 0xD5, 0x104, 0, 0);
+            n = -1;
+        }
+        if (n == ((Buf *)arg0->f50)->f20) {
+            ((Buf *)arg0->f50)->f20 = 0;
+            arg0->f18 = 1;
+            return ((Buf *)arg0->f50)->f24;
+        }
+        if (n <= 0) {
+            return n;
+        }
+        ((Buf *)arg0->f50)->f1C += n;
+        ((Buf *)arg0->f50)->f20 -= n;
+    }
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00505368.c b/src/overlays/l00_multiplayer_menu/L00_00505368.c
new file mode 100644
index 000000000..bf05f268c
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00505368.c
@@ -0,0 +1,58 @@
+/* cflags: @ee29 -O2 -G0 */
+#include "common.h"
+
+typedef struct Sock {
+    u8 pad0[0xA4];
+    s32 fA4;
+    s32 fA8;
+    s32 fAC;
+    u8 padB0[0xE8 - 0xB0];
+    s32 fE8;
+    s32 fEC;
+    s32 fF0;
+    s32 fF4;
+} Sock;
+
+typedef struct Conn {
+    u8 pad0[0x10];
+    s32 f10;
+    u8 pad14[0x4];
+    s32 f18;
+    u8 pad1C[0x54 - 0x1C];
+    s32 f54;
+} Conn;
+
+extern s32 *func_0011A1A0(void);
+extern void func_L00_004F84C8(s32, s32, s32, s32, s32);
+extern s32 func_L00_00516AB0(s32, s32, s32);
+
+s32 func_L00_00505368(Conn *c, s32 arg1, s32 arg2, s32 arg3) {
+    Sock *s;
+    s32 r;
+
+    s = ((Sock *)c->f54);
+    if (arg3 < s->fE8 || s->fF4 != arg2 || s->fEC != arg1) {
+        func_L00_004F84C8(0x14, 0xA0, 0x7F, 0, 0);
+        return -1;
+    }
+    while (1) {
+        *func_0011A1A0() = 0;
+        if (c->f10 != 0) {
+            c->f18 = 2;
+            r = func_L00_00516AB0(c->f10, ((Sock *)c->f54)->fAC + ((Sock *)c->f54)->fA8, ((Sock *)c->f54)->fA4);
+        } else {
+            func_L00_004F84C8(0x14, 0xA0, 0x80, 0, 0);
+            r = -1;
+        }
+        if (r == ((Sock *)c->f54)->fA4) {
+            ((Sock *)c->f54)->fA4 = 0;
+            c->f18 = 1;
+            return ((Sock *)c->f54)->fF0;
+        }
+        if (r <= 0) {
+            return r;
+        }
+        ((Sock *)c->f54)->fA8 += r;
+        ((Sock *)c->f54)->fA4 -= r;
+    }
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_0051E1D8.c b/src/overlays/l00_multiplayer_menu/L00_0051E1D8.c
new file mode 100644
index 000000000..73ebde2df
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_0051E1D8.c
@@ -0,0 +1,24 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+u32 func_L00_0051E1D8(s32 value) {
+    u32 out;
+    s32 top;
+    s32 nib;
+    s32 high;
+    s32 i;
+
+    out = 0;
+    top = value >> 28;
+    nib = 0xF;
+    nib = top & nib;
+    if ((top & 7) != 0) {
+        high = nib - (nib & 8);
+    } else {
+        high = 5;
+    }
+    for (i = 0; i < 7; i++) {
+        out |= ((value >> (i * 4)) & 7) << (i * 4);
+    }
+    return (out & 0xFFFFFFF) | (high << 28);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00526DA8.c b/src/overlays/l00_multiplayer_menu/L00_00526DA8.c
new file mode 100644
index 000000000..2693c46ec
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00526DA8.c
@@ -0,0 +1,66 @@
+/* cflags: @ee29 -O2 -G0 -fno-strict-aliasing */
+#include "common.h"
+
+typedef struct Sub54 {
+    u8 pad0[0x18];
+    s32 f18;
+    u8 pad1C[0x100 - 0x1C];
+    s32 f100;
+} Sub54;
+
+typedef struct Peer {
+    u8 pad0[0x54];
+    Sub54 *f54;
+} Peer;
+
+typedef struct Conn {
+    u8 pad0[0x4];
+    void *f4;
+} Conn;
+
+typedef struct Self {
+    u8 pad0[0x8];
+    Peer *f8;
+    u8 padC[0x3C - 0xC];
+    Conn *f3C;
+    u8 pad40[0x54 - 0x40];
+    Sub54 *f54;
+} Self;
+
+extern s32 func_0011A2DC(void *, void *, s32);
+extern void func_L00_004F84C8(s32, s32, s32, s32, s32);
+extern void func_L00_00505D50(Self *, s32, s32);
+extern s64 func_L00_00527340(Self *, s32, s32, s32, u64, s32 *);
+
+s32 func_L00_00526DA8(Self *self, s32 arg1, s32 arg2) {
+    s32 status;
+    s64 r;
+    s32 code;
+    s32 len;
+    void *data;
+
+    r = func_L00_00527340(self, arg1, arg2, 0x14, 0x40, &status);
+    if (status == 0) {
+        return r;
+    }
+    if (self->f54->f100 == 0) {
+        code = 10;
+        func_L00_004F84C8(0x14, 0x8C, 0x9A, 0, 0);
+    } else {
+        self->f54->f100 = 0;
+        len = self->f8->f54->f18;
+        data = self->f3C->f4;
+        if (len != r) {
+            code = 0x32;
+            func_L00_004F84C8(0x14, 0x8C, 0x6F, 0, 0);
+        } else {
+            if (func_0011A2DC(data, (u8 *)self->f54 + 0x128, len) == 0) {
+                return 1;
+            }
+            code = 0x33;
+            func_L00_004F84C8(0x14, 0x8C, 0x95, 0, 0);
+        }
+    }
+    func_L00_00505D50(self, 2, code);
+    return -1;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00545C48.c b/src/overlays/l00_multiplayer_menu/L00_00545C48.c
new file mode 100644
index 000000000..83c76c619
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00545C48.c
@@ -0,0 +1,24 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+u32 func_L00_00545C48(s32 value) {
+    u32 out;
+    s32 top;
+    s32 nib;
+    s32 high;
+    s32 i;
+
+    out = 0;
+    top = value >> 28;
+    nib = 0xF;
+    nib = top & nib;
+    if ((top & 7) != 0) {
+        high = nib - (nib & 8);
+    } else {
+        high = 5;
+    }
+    for (i = 0; i < 7; i++) {
+        out |= ((value >> (i * 4)) & 7) << (i * 4);
+    }
+    return (out & 0xFFFFFFF) | (high << 28);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00551DA0.c b/src/overlays/l00_multiplayer_menu/L00_00551DA0.c
new file mode 100644
index 000000000..0f80c6892
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00551DA0.c
@@ -0,0 +1,17 @@
+/* cflags: -Wuninitialized */
+#include "common.h"
+
+s32 func_L00_00551DA0(void *arg0) {
+    s32 (*var_2)(s32);
+    s32 var_4;
+    void *var_3;
+
+    var_3 = arg0;
+    var_2 = NULL;
+    if (var_3 != NULL) {
+        var_2 = *(s32 (**)(s32))var_3;
+        var_4 = *(s32 *)((u8 *)var_3 + 4);
+        var_2 = (s32 (*)(s32)) (var_2(var_4) != 0);
+    }
+    return (s32) var_2;
+}
\ No newline at end of file
diff --git a/src/overlays/l00_multiplayer_menu/L00_00565150.c b/src/overlays/l00_multiplayer_menu/L00_00565150.c
new file mode 100644
index 000000000..fe2f228a8
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00565150.c
@@ -0,0 +1,24 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+u32 func_L00_00565150(s32 value) {
+    u32 out;
+    s32 top;
+    s32 nib;
+    s32 high;
+    s32 i;
+
+    out = 0;
+    top = value >> 28;
+    nib = 0xF;
+    nib = top & nib;
+    if ((top & 7) != 0) {
+        high = nib - (nib & 8);
+    } else {
+        high = 5;
+    }
+    for (i = 0; i < 7; i++) {
+        out |= ((value >> (i * 4)) & 7) << (i * 4);
+    }
+    return (out & 0xFFFFFFF) | (high << 28);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_005661C8.c b/src/overlays/l00_multiplayer_menu/L00_005661C8.c
new file mode 100644
index 000000000..1079b52d8
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_005661C8.c
@@ -0,0 +1,24 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+u32 func_L00_005661C8(s32 value) {
+    u32 out;
+    s32 top;
+    s32 nib;
+    s32 high;
+    s32 i;
+
+    out = 0;
+    top = value >> 28;
+    nib = 0xF;
+    nib = top & nib;
+    if ((top & 7) != 0) {
+        high = nib - (nib & 8);
+    } else {
+        high = 5;
+    }
+    for (i = 0; i < 7; i++) {
+        out |= ((value >> (i * 4)) & 7) << (i * 4);
+    }
+    return (out & 0xFFFFFFF) | (high << 28);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_0069DA50.c b/src/overlays/l00_multiplayer_menu/L00_0069DA50.c
new file mode 100644
index 000000000..448411490
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_0069DA50.c
@@ -0,0 +1,52 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct Vtable {
+    void *unused[3];
+    u32 (*type)(Object *);
+    void *f10;
+    s32 (*supports)(Object *, u32);
+} Vtable;
+struct Object {
+    s32 f0, f4;
+    Vtable *vtable;
+};
+typedef struct {
+    s32 f0;
+    void *context;
+} Manager;
+extern Manager D_00223148[];
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, s32);
+extern u32 D_002203D0;
+static inline Object *resolve(s32 handle)
+{
+    Manager *m;
+    Object *obj;
+    void *world;
+    if (D_00223148[0].context)
+        m = D_00223148;
+    else
+        m = func_005010E0();
+    world = 0;
+    if (m->context)
+        world = *(void **)((u32)m->context + ((u32) * (s32 *)((char *)m->context + 0x14) << 2));
+    obj = func_005005E8(world, handle);
+    if (obj && obj->vtable->supports(obj, D_002203D0))
+        return obj;
+    return 0;
+}
+typedef s32 (*Callback)(Object *, f32, f32);
+extern char D_003436B0[];
+extern Callback func_L00_0069FE90(void *, u32);
+s32 func_L00_0069DA50(s32 handle, f32 a, f32 b)
+{
+    s32 result = 0;
+    Object *obj = resolve(handle);
+    if (obj) {
+        u32 type = obj->vtable->type(obj);
+        Callback callback = func_L00_0069FE90(D_003436B0, type);
+        if (callback)
+            result = callback(obj, a, b);
+    }
+    return result;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_0070B400.c b/src/overlays/l00_multiplayer_menu/L00_0070B400.c
new file mode 100644
index 000000000..bd70af2c0
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_0070B400.c
@@ -0,0 +1,50 @@
+#include "common.h"
+
+typedef struct Ent Ent;
+typedef struct EntVt EntVt;
+struct EntVt {
+    char _p0[0x144];
+    s32 (*f144)(Ent *, EntVt *);
+};
+struct Ent {
+    char _p0[0x58];
+    EntVt *f58;
+};
+
+extern s32 func_L00_005C9F50(s32);
+extern s32 func_L00_00719A28(u8 *owner, u8 *menu, s32 text, s32 a3, s32 t0, s32 t1, s32 t2, f32 f);
+extern u8 D_00220A78[];
+extern u8 *D_00220D14;
+
+s32 func_L00_0070B400(s32 arg0) {
+    s32 ret;
+    u8 *owner;
+    u8 *e;
+    u8 *o;
+    Ent *ent;
+    s32 r;
+
+    ret = 1;
+    owner = D_00220D14;
+    if (arg0 == 2) {
+        o = *(u8 **)(owner + 0x108);
+        e = NULL;
+        if (o != NULL) {
+            e = (*(u8 *)(o + 0xA8) ^ 1) ? NULL : o;
+        }
+        if (e == NULL) {
+            ret = 2;
+            func_L00_00719A28(owner, D_00220A78, func_L00_005C9F50(0x1732), 4, 0, 0, 0, 0.6f);
+            ent = *(Ent **)(D_00220D14 + 0x108);
+            r = ent->f58->f144(ent, ent->f58);
+            if (r == 5) {
+                *((u8 *)ent + 0x390) = 1;
+            } else if (r == 6) {
+                *((u8 *)ent + 0x274) = 1;
+            } else if (r == 10) {
+                *((u8 *)ent + 0x2882) = 1;
+            }
+        }
+    }
+    return ret;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00711478.c b/src/overlays/l00_multiplayer_menu/L00_00711478.c
new file mode 100644
index 000000000..ffb9716d1
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00711478.c
@@ -0,0 +1,21 @@
+#include "common.h"
+
+extern s32 func_L00_0069E7A8(s32 item, s32 mode);
+extern s32 func_L00_0069E6E0(s32 item, f32 first, f32 second);
+
+s32 func_L00_00711478(void *object, s32 mode, f32 first, f32 second)
+{
+    s32 item;
+
+    item = *(s32 *)((s8 *)object + 0x14);
+    if (item != 0) {
+        if (func_L00_0069E7A8(item, mode) != 0) {
+            if (mode != 0) {
+                return func_L00_0069E6E0(*(s32 *)((s8 *)object + 0x14), first, second);
+            }
+            return 1;
+        }
+        return 0;
+    }
+    return 0;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_007121A0.c b/src/overlays/l00_multiplayer_menu/L00_007121A0.c
new file mode 100644
index 000000000..b80a914bf
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_007121A0.c
@@ -0,0 +1,23 @@
+#include "common.h"
+
+s32 func_L00_0069CC48(s32 handle, s32 a, s32 b);
+
+s32 func_L00_007121A0(void *arg0, s32 arg1, s32 arg2) {
+    s32 temp_a0;
+    s32 temp_a0_2;
+    s32 temp_a0_3;
+
+    temp_a0 = (*(s32 *)((s8 *)(arg0) + (0x5C)));
+    if (temp_a0 != 0) {
+        func_L00_0069CC48(temp_a0, arg1, arg2);
+    }
+    temp_a0_2 = (*(s32 *)((s8 *)(arg0) + (0x64)));
+    if (temp_a0_2 != -1) {
+        func_L00_0069CC48(temp_a0_2, arg1, arg2);
+    }
+    temp_a0_3 = (*(s32 *)((s8 *)(arg0) + (0x68)));
+    if (temp_a0_3 != -1) {
+        func_L00_0069CC48(temp_a0_3, arg1, arg2);
+    }
+    return 1;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00712220.c b/src/overlays/l00_multiplayer_menu/L00_00712220.c
new file mode 100644
index 000000000..010258884
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00712220.c
@@ -0,0 +1,23 @@
+#include "common.h"
+
+s32 func_L00_0069CE38(s32 handle, s32 a, s32 b);
+
+s32 func_L00_00712220(void *arg0, s32 arg1, s32 arg2) {
+    s32 temp_a0;
+    s32 temp_a0_2;
+    s32 temp_a0_3;
+
+    temp_a0 = (*(s32 *)((s8 *)(arg0) + (0x5C)));
+    if (temp_a0 != 0) {
+        func_L00_0069CE38(temp_a0, arg1, arg2);
+    }
+    temp_a0_2 = (*(s32 *)((s8 *)(arg0) + (0x64)));
+    if (temp_a0_2 != -1) {
+        func_L00_0069CE38(temp_a0_2, arg1, arg2);
+    }
+    temp_a0_3 = (*(s32 *)((s8 *)(arg0) + (0x68)));
+    if (temp_a0_3 != -1) {
+        func_L00_0069CE38(temp_a0_3, arg1, arg2);
+    }
+    return 1;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00713360.c b/src/overlays/l00_multiplayer_menu/L00_00713360.c
new file mode 100644
index 000000000..6a076f09f
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00713360.c
@@ -0,0 +1,14 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+extern s32 func_0069D6C0(s32 handle, u32 value);
+
+s32 func_L00_00713360(void *object, u32 value)
+{
+    s32 handle = *(s32 *)((u8 *)object + 0x14);
+
+    if (handle != 0xFFFFFFFF) {
+        return func_0069D6C0(handle, value);
+    }
+    return 0;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_007141C8.c b/src/overlays/l00_multiplayer_menu/L00_007141C8.c
new file mode 100644
index 000000000..9997a5e1a
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_007141C8.c
@@ -0,0 +1,7 @@
+#include "common.h"
+
+void *func_L00_0069D9B8(s32);
+
+s32 func_L00_007141C8(void *arg0, s32 arg1) {
+    return (s32) ((*(f32 *)((s8 *)(func_L00_0069D9B8(arg1 | (*(s32 *)((s8 *)(arg0) + (0x45C))))) + (0x1C))) * 512.0f);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00714AD8.c b/src/overlays/l00_multiplayer_menu/L00_00714AD8.c
new file mode 100644
index 000000000..e65e7a5ed
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00714AD8.c
@@ -0,0 +1,41 @@
+#include "common.h"
+
+typedef struct NumericControl {
+    u8 opaque[0x70];
+    s32 value;
+    s32 minimum;
+    s32 maximum;
+    s32 step;
+} NumericControl;
+
+extern s32 func_L00_007647B0(s32 identifier);
+
+s32 func_L00_00714AD8(NumericControl *state, s32 action)
+{
+    s32 handled = 0;
+    s32 changed = 0;
+    s32 value;
+    s32 proposed;
+
+    if (action == 4 || action == 7) {
+        state->value = (s32)((u32)state->value + (u32)state->step);
+        handled = 1;
+        changed = 1;
+    } else if (action == 3) {
+        state->value = (s32)((u32)state->value - (u32)state->step);
+        handled = 1;
+        changed = 1;
+    }
+    proposed = state->value;
+    value = proposed > state->maximum ? state->maximum : proposed;
+    value = value < state->minimum ? state->minimum : value;
+    state->value = value;
+    if (changed) {
+        if (value != proposed) {
+            func_L00_007647B0(4);
+        } else {
+            func_L00_007647B0(6);
+        }
+    }
+    return handled;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00714F10.c b/src/overlays/l00_multiplayer_menu/L00_00714F10.c
new file mode 100644
index 000000000..7dc8f983a
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00714F10.c
@@ -0,0 +1,53 @@
+#include "common.h"
+
+extern s32 func_0069CC48(s32, s32, s32);
+extern u32 func_005E6358(u32, u32, s32, s32, s32, s32);
+extern s32 func_0069D318(s32, u8 *);
+extern s32 func_0069D408(s32, u32);
+extern void func_0069E7A8(s32, s32);
+
+void func_L00_00714F10(u8 *item) {
+    u32 col;
+    s32 mode;
+
+    if (*(s32 *)(item + 4) == 0) {
+        return;
+    }
+    if (*(s32 *)(item + 0x14) == 0 && *(s32 *)(item + 0x5C) == 0) {
+        return;
+    }
+    func_0069CC48(*(s32 *)(item + 0x14), 1, 0);
+    if (*(s32 *)(item + 4) == 1) {
+        func_0069CC48(*(s32 *)(item + 0x5C), 1, 0);
+        return;
+    }
+    func_0069CC48(*(s32 *)(item + 0x5C), 1, 1);
+    mode = *(s32 *)(item + 4);
+    if (mode == 3) {
+        col = 0x80808080;
+    } else if (mode == 4) {
+        col = *(u32 *)(item + 0x130);
+    } else if (mode == 5) {
+        col = func_005E6358(0x80D6CBBE, 0x66A6BEFA, 0x2D, 1, 0, 1);
+    } else if (mode == 6) {
+        col = 0x66A6BEFA;
+    } else {
+        col = *(u32 *)(item + 0x130);
+    }
+    if (*(s32 *)(item + 0x14) != 0 && item[0x18] != 0) {
+        func_0069D318(*(s32 *)(item + 0x14), item + 0x18);
+        func_0069D408(*(s32 *)(item + 0x14), col);
+        func_0069CC48(*(s32 *)(item + 0x14), 1, 1);
+    }
+    if (*(s32 *)(item + 0x5C) != 0) {
+        if (*(s32 *)(item + 0x128) != 0) {
+            if (item[0x134] != 0) {
+                func_0069E7A8(*(s32 *)(item + 0x5C), 1);
+            } else {
+                func_0069E7A8(*(s32 *)(item + 0x5C), 0);
+            }
+        }
+        func_0069D318(*(s32 *)(item + 0x5C), item + 0x60);
+        func_0069D408(*(s32 *)(item + 0x5C), col);
+    }
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00717580.c b/src/overlays/l00_multiplayer_menu/L00_00717580.c
new file mode 100644
index 000000000..8fd588dd6
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00717580.c
@@ -0,0 +1,45 @@
+#include "common.h"
+
+s32 func_0069DA50(s32 handle, f32 a, f32 b);
+
+s32 func_L00_00717580(void *arg0, f32 fparg0, f32 fparg1) {
+    s32 temp_a0;
+    s32 temp_a0_2;
+    s32 temp_a0_3;
+    s32 temp_a0_4;
+    s32 temp_a0_5;
+    s32 temp_a0_6;
+    s32 temp_a0_7;
+    s32 var_s1;
+
+    var_s1 = 0;
+    temp_a0 = (*(s32 *)((s8 *)(arg0) + (0x14)));
+    if (temp_a0 != 0) {
+        var_s1 = func_0069DA50(temp_a0, fparg0, fparg1);
+    }
+    temp_a0_2 = (*(s32 *)((s8 *)(arg0) + (0x5C)));
+    if (temp_a0_2 != 0) {
+        var_s1 |= func_0069DA50(temp_a0_2, fparg0, fparg1);
+    }
+    temp_a0_3 = (*(s32 *)((s8 *)(arg0) + (0x12C)));
+    if (temp_a0_3 != -1) {
+        var_s1 |= func_0069DA50(temp_a0_3, fparg0, fparg1);
+    }
+    temp_a0_4 = (*(s32 *)((s8 *)(arg0) + (0x130)));
+    if (temp_a0_4 != -1) {
+        var_s1 |= func_0069DA50(temp_a0_4, fparg0, fparg1);
+    }
+    temp_a0_5 = (*(s32 *)((s8 *)(arg0) + (0x134)));
+    if (temp_a0_5 != -1) {
+        var_s1 |= func_0069DA50(temp_a0_5, fparg0, fparg1);
+    }
+    temp_a0_6 = (*(s32 *)((s8 *)(arg0) + (0x138)));
+    if (temp_a0_6 != -1) {
+        var_s1 |= func_0069DA50(temp_a0_6, fparg0, fparg1);
+    }
+    temp_a0_7 = (*(s32 *)((s8 *)(arg0) + (0x13C)));
+    if (temp_a0_7 != -1) {
+        var_s1 |= func_0069DA50(temp_a0_7, fparg0, fparg1);
+    }
+    return var_s1 != 0;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00717678.c b/src/overlays/l00_multiplayer_menu/L00_00717678.c
new file mode 100644
index 000000000..a57ff9c3c
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00717678.c
@@ -0,0 +1,45 @@
+#include "common.h"
+
+s32 func_0069CC48(s32 handle, s32 a, s32 b);
+
+s32 func_L00_00717678(void *arg0, s32 arg1, s32 arg2) {
+    s32 temp_a0;
+    s32 temp_a0_2;
+    s32 temp_a0_3;
+    s32 temp_a0_4;
+    s32 temp_a0_5;
+    s32 temp_a0_6;
+    s32 temp_a0_7;
+    s32 var_s3;
+
+    temp_a0 = (*(s32 *)((s8 *)(arg0) + (0x14)));
+    var_s3 = 0;
+    if (temp_a0 != 0) {
+        var_s3 = func_0069CC48(temp_a0, arg1, arg2);
+    }
+    temp_a0_2 = (*(s32 *)((s8 *)(arg0) + (0x5C)));
+    if (temp_a0_2 != 0) {
+        var_s3 |= func_0069CC48(temp_a0_2, arg1, arg2);
+    }
+    temp_a0_3 = (*(s32 *)((s8 *)(arg0) + (0x12C)));
+    if (temp_a0_3 != -1) {
+        var_s3 |= func_0069CC48(temp_a0_3, arg1, arg2);
+    }
+    temp_a0_4 = (*(s32 *)((s8 *)(arg0) + (0x130)));
+    if (temp_a0_4 != -1) {
+        var_s3 |= func_0069CC48(temp_a0_4, arg1, arg2);
+    }
+    temp_a0_5 = (*(s32 *)((s8 *)(arg0) + (0x134)));
+    if (temp_a0_5 != -1) {
+        var_s3 |= func_0069CC48(temp_a0_5, arg1, arg2);
+    }
+    temp_a0_6 = (*(s32 *)((s8 *)(arg0) + (0x138)));
+    if (temp_a0_6 != -1) {
+        var_s3 |= func_0069CC48(temp_a0_6, arg1, arg2);
+    }
+    temp_a0_7 = (*(s32 *)((s8 *)(arg0) + (0x13C)));
+    if (temp_a0_7 != -1) {
+        var_s3 |= func_0069CC48(temp_a0_7, arg1, arg2);
+    }
+    return var_s3 != 0;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_007177B0.c b/src/overlays/l00_multiplayer_menu/L00_007177B0.c
new file mode 100644
index 000000000..22cccc25d
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_007177B0.c
@@ -0,0 +1,45 @@
+#include "common.h"
+
+s32 func_L00_0069CE38(s32 handle, s32 a, s32 b);
+
+s32 func_L00_007177B0(void *arg0, s32 arg1, s32 arg2) {
+    s32 temp_a0;
+    s32 temp_a0_2;
+    s32 temp_a0_3;
+    s32 temp_a0_4;
+    s32 temp_a0_5;
+    s32 temp_a0_6;
+    s32 temp_a0_7;
+    s32 var_s3;
+
+    temp_a0 = (*(s32 *)((s8 *)(arg0) + (0x14)));
+    var_s3 = 0;
+    if (temp_a0 != 0) {
+        var_s3 = func_L00_0069CE38(temp_a0, arg1, arg2);
+    }
+    temp_a0_2 = (*(s32 *)((s8 *)(arg0) + (0x5C)));
+    if (temp_a0_2 != 0) {
+        var_s3 |= func_L00_0069CE38(temp_a0_2, arg1, arg2);
+    }
+    temp_a0_3 = (*(s32 *)((s8 *)(arg0) + (0x12C)));
+    if (temp_a0_3 != -1) {
+        var_s3 |= func_L00_0069CE38(temp_a0_3, arg1, arg2);
+    }
+    temp_a0_4 = (*(s32 *)((s8 *)(arg0) + (0x130)));
+    if (temp_a0_4 != -1) {
+        var_s3 |= func_L00_0069CE38(temp_a0_4, arg1, arg2);
+    }
+    temp_a0_5 = (*(s32 *)((s8 *)(arg0) + (0x134)));
+    if (temp_a0_5 != -1) {
+        var_s3 |= func_L00_0069CE38(temp_a0_5, arg1, arg2);
+    }
+    temp_a0_6 = (*(s32 *)((s8 *)(arg0) + (0x138)));
+    if (temp_a0_6 != -1) {
+        var_s3 |= func_L00_0069CE38(temp_a0_6, arg1, arg2);
+    }
+    temp_a0_7 = (*(s32 *)((s8 *)(arg0) + (0x13C)));
+    if (temp_a0_7 != -1) {
+        var_s3 |= func_L00_0069CE38(temp_a0_7, arg1, arg2);
+    }
+    return var_s3 != 0;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_007178A8.c b/src/overlays/l00_multiplayer_menu/L00_007178A8.c
new file mode 100644
index 000000000..a7d414735
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_007178A8.c
@@ -0,0 +1,7 @@
+#include "common.h"
+
+void *func_L00_0069D9B8(s32);
+
+s32 func_L00_007178A8(void *arg0, s32 arg1) {
+    return (s32) ((*(f32 *)((s8 *)(func_L00_0069D9B8(arg1 | (*(s32 *)((s8 *)(arg0) + (0x10))))) + (0x1C))) * 512.0f);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00719248.c b/src/overlays/l00_multiplayer_menu/L00_00719248.c
new file mode 100644
index 000000000..516004b82
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00719248.c
@@ -0,0 +1,47 @@
+#include "common.h"
+
+extern s32 func_L00_007647B0(s32 identifier);
+
+void func_L00_00719248(void *unused, s64 from, s64 to)
+{
+    s32 sound = -1;
+    if (from == 29 && to == 27)
+        sound = 45;
+    else if (from == 3 && to == 27)
+        sound = 62;
+    else if (from == 19 && to == 27)
+        sound = 68;
+    else if (from == 32 && to == 27)
+        sound = 72;
+    else if (from == 29 && to == 3)
+        sound = 78;
+    else if (from == 29 && to == 19)
+        sound = 79;
+    else if (from == 29 && to == 32)
+        sound = 80;
+    else if (from == 5 && to == 27)
+        sound = 55;
+    else if (from == 6 && to == 27)
+        sound = 55;
+    else if (from == 6 && (to == 8 || to == 5))
+        sound = 59;
+    else if (from == 7 && to == 27)
+        sound = 55;
+    else if (from == 8 && to == 27)
+        sound = 55;
+    else if (from == 9 && to == 27)
+        sound = 55;
+    else if (from == 9 && (to == 8 || to == 5))
+        sound = 61;
+    else if (from == 10 && (to == 8 || to == 5))
+        sound = 57;
+    else if (from == 36 && to == 27)
+        sound = 74;
+    else if (from == 16 && to == 15)
+        sound = 75;
+    else if (from == 29 && to == 16)
+        sound = 77;
+    if (sound != -1) {
+        func_L00_007647B0(sound);
+    }
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00721A28.c b/src/overlays/l00_multiplayer_menu/L00_00721A28.c
new file mode 100644
index 000000000..de8adb98b
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00721A28.c
@@ -0,0 +1,62 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+extern void *D_002233A4;
+extern char D_00220E50[], D_00220E58[], D_00220E60[];
+extern int func_004534D0(void *);
+extern int func_L00_00767A50(void *, int);
+extern void *func_0011AFC8(void *, const void *, unsigned int);
+extern int func_0011D920(char *, const char *, ...);
+extern int func_L00_00772630(void *, int, int, int *);
+extern int func_L00_00725150(void *, int);
+#define FIELD(p, t, n) (*(t *)((char *)(p) + (n)))
+typedef void (*SetTextMethod)(void *, const char *);
+typedef void (*ClearMethod)(void *);
+#define SETTEXT(p, s) FIELD(FIELD(p, void *, 0x58), SetTextMethod, 0xE8)(p, s)
+#define CLEAR(p) FIELD(FIELD(p, void *, 0x58), ClearMethod, 0xE4)(p)
+void func_L00_00721A28(void *self) {
+    char tag[16];
+    char name[16];
+    char text[16];
+
+    int stats[100];
+    void *profile;
+    void *widget;
+    void *widget6;
+    void *widget5;
+    void *widget4;
+    void *widget3;
+    void *widget2;
+    void *widget1;
+    int first, second;
+    profile = FIELD(D_002233A4, void *, 0x3C);
+    func_004534D0((char *)self + 0x384);
+    if (FIELD(self, int, 0x384) <= 0) {
+        func_L00_00767A50(profile, 0);
+        widget = FIELD(self, void *, 0xC0);
+        FIELD(self, int, 0x384) = 0x384;
+        SETTEXT(widget, (char *)profile + 4);
+        func_0011AFC8(tag, (char *)profile + 44, 4);
+        tag[4] = 0;
+        func_0011D920(name, D_00220E50, tag);
+        widget1 = FIELD(self, void *, 0xD4);
+        SETTEXT(widget1, name);
+        if (func_L00_00772630(FIELD(D_002233A4, void *, 0x50), FIELD(profile, int, 0), 1, stats)) {
+            func_0011D920(text, D_00220E58, stats[2], stats[3]);
+            widget2 = FIELD(self, void *, 0xCC);
+            SETTEXT(widget2, text);
+            func_0011D920(text, D_00220E58, stats[0], stats[1]);
+            widget3 = FIELD(self, void *, 0xD0);
+            SETTEXT(widget3, text);
+        } else {
+            widget4 = FIELD(self, void *, 0xCC);
+            CLEAR(widget4);
+            widget5 = FIELD(self, void *, 0xD0);
+            CLEAR(widget5);
+        }
+        first = func_L00_00725150(profile, 4);
+        second = func_L00_00725150(profile, 10);
+        func_0011D920(text, D_00220E60, first, second);
+        widget6 = FIELD(self, void *, 0xC8);
+        SETTEXT(widget6, text);
+    }
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00725150.c b/src/overlays/l00_multiplayer_menu/L00_00725150.c
new file mode 100644
index 000000000..8f6f54668
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00725150.c
@@ -0,0 +1,16 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+void *func_L00_0076C5E0(s32, s32, s32);
+
+s32 func_L00_00725150(s32 arg0, s32 arg1) {
+    void *temp_2;
+
+    if (arg0 != 0) {
+        temp_2 = func_L00_0076C5E0(arg0, arg1, 1);
+        if (temp_2 != NULL) {
+            return *(s32 *)((u8 *)temp_2 + 0x18);
+        }
+    }
+    return 0;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00725188.c b/src/overlays/l00_multiplayer_menu/L00_00725188.c
new file mode 100644
index 000000000..1eacb72f9
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00725188.c
@@ -0,0 +1,62 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+extern void *D_002233A4;
+extern char D_00220EA0[], D_00220EA8[], D_00220EB0[];
+extern int func_004534D0(void *);
+extern int func_L00_00767A50(void *, int);
+extern void *func_0011AFC8(void *, const void *, unsigned int);
+extern int func_0011D920(char *, const char *, ...);
+extern int func_L00_00772630(void *, int, int, int *);
+extern int func_L00_00725150(void *, int);
+#define FIELD(p, t, n) (*(t *)((char *)(p) + (n)))
+typedef void (*SetTextMethod)(void *, const char *);
+typedef void (*ClearMethod)(void *);
+#define SETTEXT(p, s) FIELD(FIELD(p, void *, 0x58), SetTextMethod, 0xE8)(p, s)
+#define CLEAR(p) FIELD(FIELD(p, void *, 0x58), ClearMethod, 0xE4)(p)
+void func_L00_00725188(void *self) {
+    char tag[16];
+    char name[16];
+    char text[16];
+
+    int stats[100];
+    void *profile;
+    void *widget;
+    void *widget6;
+    void *widget5;
+    void *widget4;
+    void *widget3;
+    void *widget2;
+    void *widget1;
+    int first, second;
+    profile = FIELD(D_002233A4, void *, 0x3C);
+    func_004534D0((char *)self + 0x370);
+    if (FIELD(self, int, 0x370) <= 0) {
+        func_L00_00767A50(profile, 0);
+        widget = FIELD(self, void *, 0xC0);
+        FIELD(self, int, 0x370) = 0x384;
+        SETTEXT(widget, (char *)profile + 4);
+        func_0011AFC8(tag, (char *)profile + 44, 4);
+        tag[4] = 0;
+        func_0011D920(name, D_00220EA0, tag);
+        widget1 = FIELD(self, void *, 0xD4);
+        SETTEXT(widget1, name);
+        if (func_L00_00772630(FIELD(D_002233A4, void *, 0x50), FIELD(profile, int, 0), 1, stats)) {
+            func_0011D920(text, D_00220EA8, stats[2], stats[3]);
+            widget2 = FIELD(self, void *, 0xCC);
+            SETTEXT(widget2, text);
+            func_0011D920(text, D_00220EA8, stats[0], stats[1]);
+            widget3 = FIELD(self, void *, 0xD0);
+            SETTEXT(widget3, text);
+        } else {
+            widget4 = FIELD(self, void *, 0xCC);
+            CLEAR(widget4);
+            widget5 = FIELD(self, void *, 0xD0);
+            CLEAR(widget5);
+        }
+        first = func_L00_00725150(profile, 4);
+        second = func_L00_00725150(profile, 10);
+        func_0011D920(text, D_00220EB0, first, second);
+        widget6 = FIELD(self, void *, 0xC8);
+        SETTEXT(widget6, text);
+    }
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00729600.c b/src/overlays/l00_multiplayer_menu/L00_00729600.c
new file mode 100644
index 000000000..85d5197d9
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00729600.c
@@ -0,0 +1,10 @@
+#include "common.h"
+typedef struct Record {
+    u32 words[35];
+} Record;
+void func_L00_00729600(Record *left, Record *right)
+{
+    Record temporary = *left;
+    *left = *right;
+    *right = temporary;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_0072BD20.c b/src/overlays/l00_multiplayer_menu/L00_0072BD20.c
new file mode 100644
index 000000000..ffc8bb39a
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_0072BD20.c
@@ -0,0 +1,12 @@
+#include "common.h"
+
+extern s32 func_L00_0071AF88(void *, s32);
+extern void func_L00_0070C3E0(void *, s32);
+extern u8 D_004BBD20[];
+
+s32 func_L00_0072BD20(void *arg0, s32 arg1)
+{
+    *(void **)((u8 *)arg0 + 88) = D_004BBD20;
+    func_L00_0070C3E0((u8 *)arg0 + 676, 2);
+    return func_L00_0071AF88(arg0, arg1);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_0072FDF0.c b/src/overlays/l00_multiplayer_menu/L00_0072FDF0.c
new file mode 100644
index 000000000..81368bd6b
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_0072FDF0.c
@@ -0,0 +1,12 @@
+#include "common.h"
+
+extern s32 func_L00_0071AF88(void *, s32);
+extern void func_L00_0070C3E0(void *, s32);
+extern u8 D_004BBF70[];
+
+s32 func_L00_0072FDF0(void *arg0, s32 arg1)
+{
+    *(void **)((u8 *)arg0 + 88) = D_004BBF70;
+    func_L00_0070C3E0((u8 *)arg0 + 0xCC8, 2);
+    return func_L00_0071AF88(arg0, arg1);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00734928.c b/src/overlays/l00_multiplayer_menu/L00_00734928.c
new file mode 100644
index 000000000..526f91705
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00734928.c
@@ -0,0 +1,12 @@
+#include "common.h"
+
+extern s32 func_L00_0071AF88(void *, s32);
+extern void func_L00_0070C3E0(void *, s32);
+extern u8 D_004BC898[];
+
+s32 func_L00_00734928(void *arg0, s32 arg1)
+{
+    *(void **)((u8 *)arg0 + 88) = D_004BC898;
+    func_L00_0070C3E0((u8 *)arg0 + 0x260, 2);
+    return func_L00_0071AF88(arg0, arg1);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_0073F590.c b/src/overlays/l00_multiplayer_menu/L00_0073F590.c
new file mode 100644
index 000000000..304cc6442
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_0073F590.c
@@ -0,0 +1,15 @@
+#include "common.h"
+
+void func_L00_0073F590(char *arg0) {
+    char **p = (char **)(arg0 + 0xd4);
+    s32 i;
+    *(s32 *)(arg0 + 0x36C) = -1;
+    i = 10;
+    do {
+        char *v;
+        i--;
+        v = *p;
+        (*(void (**)(char *))((*(char **)(v + 0x58)) + 0xe4))(v);
+        p++;
+    } while (i >= 0);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_007458C8.c b/src/overlays/l00_multiplayer_menu/L00_007458C8.c
new file mode 100644
index 000000000..38cd56eaa
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_007458C8.c
@@ -0,0 +1,32 @@
+#include "common.h"
+
+typedef struct Part Part;
+typedef struct {
+    u8 pad0[0x20];
+    void (*setMode)(Part *, s32, s32);
+} PartVt;
+struct Part {
+    u8 pad0[0x58];
+    PartVt *vt;
+};
+
+typedef struct {
+    u8 pad0[0xB0];
+    Part *parts[62];
+} Model;
+
+void func_L00_007458C8(Model *m) {
+    s32 i;
+    s32 j;
+
+    m->parts[0]->vt->setMode(m->parts[0], 2, 0);
+    m->parts[5]->vt->setMode(m->parts[5], 2, 0);
+    for (j = 0; j < 5; j++) {
+        m->parts[7 + j]->vt->setMode(m->parts[7 + j], 2, 0);
+    }
+    for (i = 0; i < 10; i++) {
+        for (j = 0; j < 5; j++) {
+            m->parts[12 + i * 5 + j]->vt->setMode(m->parts[12 + i * 5 + j], 2, 0);
+        }
+    }
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_0074AC98.c b/src/overlays/l00_multiplayer_menu/L00_0074AC98.c
new file mode 100644
index 000000000..42fb7128f
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_0074AC98.c
@@ -0,0 +1,12 @@
+#include "common.h"
+
+extern s32 func_L00_0071AF88(void *, s32);
+extern void func_L00_0070C3E0(void *, s32);
+extern u8 D_004BEAB0[];
+
+s32 func_L00_0074AC98(void *arg0, s32 arg1)
+{
+    *(void **)((u8 *)arg0 + 88) = D_004BEAB0;
+    func_L00_0070C3E0((u8 *)arg0 + 0x278, 2);
+    return func_L00_0071AF88(arg0, arg1);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_007527A8.c b/src/overlays/l00_multiplayer_menu/L00_007527A8.c
new file mode 100644
index 000000000..55f0a82ce
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_007527A8.c
@@ -0,0 +1,12 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+s32 func_L00_00751B78();
+s32 D_002213B8 = 0;
+s32 D_002213BC = 0;
+
+void func_L00_007527A8(s32 arg0, s32 arg1) {
+    func_L00_00751B78();
+    D_002213B8 = arg0;
+    D_002213BC = arg1;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00755A20.c b/src/overlays/l00_multiplayer_menu/L00_00755A20.c
new file mode 100644
index 000000000..2581c66cd
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00755A20.c
@@ -0,0 +1,15 @@
+/* cflags: @ee29 -O2 -G8 -fno-schedule-insns2 -Wuninitialized */
+#include "common.h"
+
+extern s16 func_L00_005C82E0(void);
+extern s32 D_002215CC;
+
+s32 func_L00_00755A20(void) {
+    s32 result;
+    if (func_L00_005C82E0() == 2) {
+        D_002215CC = result = 6;
+    } else {
+        D_002215CC = result = 7;
+    }
+    return result;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_0075B8F8.c b/src/overlays/l00_multiplayer_menu/L00_0075B8F8.c
new file mode 100644
index 000000000..2a165578e
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_0075B8F8.c
@@ -0,0 +1,43 @@
+#include "common.h"
+
+extern u8 D_001723B0[];
+typedef struct {
+    u8 pad0[0x104];
+    u8 ids[10];
+    u8 pad10E[0x124 - 0x10E];
+    f32 vals[10];
+} Board;
+extern Board *D_0021DFE8;
+extern u8 D_001725F0[];
+extern s32 func_0070C410(s32);
+extern void func_0070CB48(void *, s32, void *);
+extern s32 func_L00_0070C368(void *);
+extern void func_L00_0070C3E0(void *, s32);
+extern void func_L00_0070C528(void *, s32, s32);
+extern s32 func_L00_0077B8A0(f32);
+
+void func_L00_0075B8F8(void) {
+    u8 buf[0x470];
+    s32 sum;
+    s32 count;
+    s32 i;
+    s32 avg;
+
+    if (D_001723B0[0] != 0 && D_0021DFE8 != NULL) {
+        sum = 0;
+        count = 0;
+        for (i = 0; i < 10; i++) {
+            if (D_0021DFE8->ids[i] != 0xFF) {
+                count++;
+                sum += func_L00_0077B8A0(D_0021DFE8->vals[i]);
+            }
+        }
+        if (count > 0) {
+            avg = (f32)sum / (f32)count;
+            func_L00_0070C368(buf);
+            func_L00_0070C528(buf, func_0070C410(4), avg);
+            func_0070CB48(buf, 4, D_001725F0);
+            func_L00_0070C3E0(buf, 2);
+        }
+    }
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_0075C8C0.c b/src/overlays/l00_multiplayer_menu/L00_0075C8C0.c
new file mode 100644
index 000000000..f85ad5c81
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_0075C8C0.c
@@ -0,0 +1,10 @@
+#include "common.h"
+
+extern u8 *D_0021DFE8;
+s32 func_L00_0075C8C0(const u8 *object,s32 index)
+{
+    s32 value=*(const s32 *)((u32)object+((u32)index<<2)+0x270U);
+    if(value<0 || D_0021DFE8==0 ||
+       *(u8 *)((u32)D_0021DFE8+(u32)value+0x104U)==255)value=-1;
+    return value;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00762030.c b/src/overlays/l00_multiplayer_menu/L00_00762030.c
new file mode 100644
index 000000000..b304d0869
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00762030.c
@@ -0,0 +1,59 @@
+#include "common.h"
+
+extern void func_L00_007647B0(s32);
+
+typedef struct Part Part;
+typedef struct {
+    u8 pad0[0x20];
+    void (*setMode)(Part *, s32, s32);
+} PartVt;
+struct Part {
+    u8 pad0[0x4];
+    s32 state;
+    u8 pad8[0x58 - 0x8];
+    PartVt *vt;
+};
+
+typedef struct {
+    u8 pad0[0xB0];
+    Part *parts[96];
+    s32 cur;
+} Menu;
+
+s32 func_L00_00762030(Menu *m, s32 dir, s32 lo, s32 hi) {
+    s32 delta;
+    s32 next;
+    s32 state;
+
+    delta = 1;
+    if (dir == 1) {
+        delta = -1;
+    } else if (dir != 2) {
+        delta = 0;
+    }
+    next = m->cur + delta;
+    if (next >= lo && next <= hi) {
+        state = m->parts[next]->state;
+        if (state != 0) {
+            if (state != 1) {
+                func_L00_007647B0(3);
+                m->parts[m->cur]->vt->setMode(m->parts[m->cur], 2, 0);
+                m->cur = next;
+                goto out;
+            }
+        }
+    }
+    if (next < lo || next > hi) {
+        func_L00_007647B0(4);
+    } else {
+        state = m->parts[next]->state;
+        if (state != 0) {
+            if (state != 1) {
+                goto out;
+            }
+        }
+        func_L00_007647B0(4);
+    }
+out:
+    return 1;
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00766EB8.c b/src/overlays/l00_multiplayer_menu/L00_00766EB8.c
new file mode 100644
index 000000000..f60d5aebd
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00766EB8.c
@@ -0,0 +1,72 @@
+#include "common.h"
+
+void func_0076C820(s32 object, u8 *arg1);
+void func_0076C860(void *object, void *queue);
+void func_0076C8D0(void *object, void *queue);
+void func_0076C940(void *object, void *queue);
+void func_0076C9B0(void *object, void *queue);
+void func_0076CA20(void *object, void *queue);
+void func_0076CA90(void *object, void *queue);
+
+void func_L00_00766EB8(void *object) {
+    (*(s32 *)((s8 *)(object) + (0x3D4))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x3DC))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x3E0))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x40C))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x414))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x418))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x444))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x44C))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x450))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x47C))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x484))) = -1;
+    (*(s8 *)((s8 *)(object) + (0x30))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x58))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x60))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x68))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x78))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x80))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x88))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x90))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x98))) = 0;
+    (*(s8 *)((s8 *)(object) + (0xA0))) = 0;
+    (*(s8 *)((s8 *)(object) + (0xA8))) = 0;
+    (*(s8 *)((s8 *)(object) + (0xB0))) = 0;
+    (*(s8 *)((s8 *)(object) + (0xB8))) = 0;
+    (*(s8 *)((s8 *)(object) + (0xC0))) = 0;
+    (*(s8 *)((s8 *)(object) + (0xC8))) = 0;
+    (*(s8 *)((s8 *)(object) + (0xF0))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x23C))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x3A8))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x3D8))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x410))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x448))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x480))) = 0;
+    (*(s32 *)((s8 *)(object) + (0x488))) = -1;
+    (*(s8 *)((s8 *)(object) + (0x4C0))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x500))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x538))) = 0;
+    (*(s32 *)((s8 *)(object) + (0x4BC))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x4C4))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x4C8))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x4FC))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x504))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x508))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x534))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x53C))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x540))) = -1;
+    (*(s32 *)((s8 *)(object) + (0))) = -1;
+    func_0076C820((*(s32 *)((s8 *)(object) + (0x400))), (u8 *)object + 0x3E8);
+    func_0076C860((*(void **)((s8 *)(object) + (0x438))), (u8 *)object + 0x420);
+    func_0076C860((*(void **)((s8 *)(object) + (0x438))), (u8 *)object + 0x42C);
+    func_0076C8D0((*(void **)((s8 *)(object) + (0x470))), (u8 *)object + 0x458);
+    func_0076C8D0((*(void **)((s8 *)(object) + (0x470))), (u8 *)object + 0x464);
+    func_0076C940((*(void **)((s8 *)(object) + (0x4A8))), (u8 *)object + 0x490);
+    func_0076C940((*(void **)((s8 *)(object) + (0x4A8))), (u8 *)object + 0x49C);
+    func_0076C9B0((*(void **)((s8 *)(object) + (0x4E8))), (u8 *)object + 0x4D0);
+    func_0076C9B0((*(void **)((s8 *)(object) + (0x4E8))), (u8 *)object + 0x4DC);
+    func_0076CA20((*(void **)((s8 *)(object) + (0x528))), (u8 *)object + 0x510);
+    func_0076CA20((*(void **)((s8 *)(object) + (0x528))), (u8 *)object + 0x51C);
+    func_0076CA90((*(void **)((s8 *)(object) + (0x560))), (u8 *)object + 0x548);
+    func_0076CA90((*(void **)((s8 *)(object) + (0x560))), (u8 *)object + 0x554);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00770340.c b/src/overlays/l00_multiplayer_menu/L00_00770340.c
new file mode 100644
index 000000000..ebe359238
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00770340.c
@@ -0,0 +1,15 @@
+#include "common.h"
+
+void func_L00_00770D40(s32 object, u8 *arg1);
+
+void func_L00_00770340(void *object) {
+    (*(s32 *)((s8 *)(object) + (0x18))) = 0x2710;
+    (*(s8 *)((s8 *)(object) + (0))) = 0;
+    (*(s8 *)((s8 *)(object) + (0xC))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x14))) = 0;
+    (*(s32 *)((s8 *)(object) + (0x1C))) = -1;
+    (*(s8 *)((s8 *)(object) + (0x20))) = 0;
+    (*(s32 *)((s8 *)(object) + (0x24))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x28))) = -1;
+    func_L00_00770D40((*(s32 *)((s8 *)(object) + (0x48))), (u8 *)object + 0x30);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00770DB0.c b/src/overlays/l00_multiplayer_menu/L00_00770DB0.c
new file mode 100644
index 000000000..c45094f40
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00770DB0.c
@@ -0,0 +1,13 @@
+#include "common.h"
+
+void func_L00_007719E0(s32 object, u8 *arg1);
+
+void func_L00_00770DB0(void *object) {
+    (*(s32 *)((s8 *)(object) + (4))) = -1;
+    (*(s8 *)((s8 *)(object) + (8))) = 0;
+    (*(s32 *)((s8 *)(object) + (0xC))) = -1;
+    (*(s32 *)((s8 *)(object) + (0x10))) = -1;
+    (*(s8 *)((s8 *)(object) + (0x1C))) = 0;
+    (*(s8 *)((s8 *)(object) + (0x24))) = 0;
+    func_L00_007719E0((*(s32 *)((s8 *)(object) + (0x48))), (u8 *)object + 0x30);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00771A48.c b/src/overlays/l00_multiplayer_menu/L00_00771A48.c
new file mode 100644
index 000000000..e7b415b83
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00771A48.c
@@ -0,0 +1,12 @@
+#include "common.h"
+
+void func_L00_00772A60(s32 arg0, u8 *arg1);
+void func_L00_00771A48(void *arg0)
+{
+  *((s32 *) (((s8 *) arg0) + 4)) = -1;
+  *((s8 *) (((s8 *) arg0) + 8)) = 0;
+  *((s8 *) (((s8 *) arg0) + 0x14)) = 0;
+  *((s32 *) (((s8 *) arg0) + 0xC)) = -1;
+  *((s32 *) (((s8 *) arg0) + 0x10)) = -1;
+  func_L00_00772A60(*((s32 *) (((s8 *) arg0) + 0x80)), arg0 + 0x68);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00772B88.c b/src/overlays/l00_multiplayer_menu/L00_00772B88.c
new file mode 100644
index 000000000..ecc85eb80
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00772B88.c
@@ -0,0 +1,12 @@
+#include "common.h"
+
+void func_00773130(void *object, void *queue);
+
+void func_L00_00772B88(void *object) {
+    (*(s8 *)((s8 *)(object) + (0))) = 0;
+    (*(s32 *)((s8 *)(object) + (4))) = -1;
+    (*(s32 *)((s8 *)(object) + (8))) = -1;
+    (*(s8 *)((s8 *)(object) + (0xC))) = 0;
+    (*(s8 *)((s8 *)(object) + (0xD))) = 0;
+    func_00773130((*(void **)((s8 *)(object) + (0x20))), (u8 *)object + 0x14);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00776698.c b/src/overlays/l00_multiplayer_menu/L00_00776698.c
new file mode 100644
index 000000000..ae468d7df
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00776698.c
@@ -0,0 +1,26 @@
+#include "common.h"
+
+void func_L00_00776698(void *arg0)
+{
+  s32 var_a1;
+  s8 *temp_v0;
+  void *var_v1;
+  u32 rac4_address_0;
+  *((s32 *) (((s8 *) arg0) + 0x1E4)) = 1;
+  var_v1 = arg0 + 0x24C;
+  *((s8 *) (((s8 *) arg0) + 0)) = 0;
+  var_a1 = 0;
+  *((s8 *) (((s8 *) arg0) + 0x14C)) = 0;
+  *((s8 *) (((s8 *) arg0) + 0x1C0)) = 0;
+  do
+  {
+    rac4_address_0 = ((u32) arg0) + ((u32) 0x238);
+    temp_v0 = (s8 *) (rac4_address_0 + ((u32) var_a1));
+    *((s32 *) (((s8 *) var_v1) + (-0x64))) = -1;
+    *((s32 *) (((s8 *) var_v1) + 0)) = 0;
+    var_a1 += 1;
+    *temp_v0 = 0;
+    var_v1 += 4;
+  }
+  while (var_a1 < 0x14);
+}
diff --git a/src/overlays/l00_multiplayer_menu/L00_00777150.c b/src/overlays/l00_multiplayer_menu/L00_00777150.c
new file mode 100644
index 000000000..9ac78af2e
--- /dev/null
+++ b/src/overlays/l00_multiplayer_menu/L00_00777150.c
@@ -0,0 +1,27 @@
+#include "common.h"
+
+void func_00779128(s32 object, u8 *arg1);
+void func_007791D8(s32 object, u8 *arg1);
+void func_L00_00777150(void *object)
+{
+  *((s8 *) (((s8 *) object) + 4)) = 0;
+  *((s8 *) (((s8 *) object) + 0xC0)) = 0;
+  *((s8 *) (((s8 *) object) + 0xE4)) = 0;
+  *((s8 *) (((s8 *) object) + 0xEC)) = 0;
+  *((s8 *) (((s8 *) object) + 0xF4)) = 0;
+  *((s8 *) (((s8 *) object) + 0x15D)) = 0;
+  *((s8 *) (((s8 *) object) + 0x168)) = 0;
+  *((s8 *) (((s8 *) object) + 0x199)) = 0;
+  *((s8 *) (((s8 *) object) + 0x1A4)) = 0;
+  *((s32 *) (((s8 *) object) + 0)) = -1;
+  *((s32 *) (((s8 *) object) + 0x160)) = -1;
+  *((s32 *) (((s8 *) object) + 0x164)) = -1;
+  *((s32 *) (((s8 *) object) + 0x16C)) = 0x2710;
+  *((s32 *) (((s8 *) object) + 0x1A8)) = 0x2710;
+  *((s32 *) (((s8 *) object) + 0x170)) = -1;
+  *((s32 *) (((s8 *) object) + 0x19C)) = -1;
+  *((s32 *) (((s8 *) object) + 0x1A0)) = -1;
+  *((s32 *) (((s8 *) object) + 0x1AC)) = -1;
+  func_00779128(*((s32 *) (((s8 *) object) + 0x190)), (u8 *)object + 0x178);
+  func_007791D8(*((s32 *) (((s8 *) object) + 0x1CC)), (u8 *)object + 0x1B4);
+}
diff --git a/src/overlays/l01_dreadzone_station/L01_004B8F68.c b/src/overlays/l01_dreadzone_station/L01_004B8F68.c
new file mode 100644
index 000000000..87bc181f6
--- /dev/null
+++ b/src/overlays/l01_dreadzone_station/L01_004B8F68.c
@@ -0,0 +1,21 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+extern s64 func_L01_004B8360(void *object);
+
+u32 func_L01_004B8F68(void *object)
+{
+    u32 value;
+    u32 result;
+    u8 disabled;
+
+    value = (u32)*(u8 **)((u8 *)object + 0xAC);
+    disabled = ((u8 *)value)[0x458];
+    result = 0;
+    if (disabled == 0) {
+        value = func_L01_004B8360(object) != 0;
+        result = value;
+    }
+    value = result;
+    return value;
+}
diff --git a/src/overlays/l05_dark_cathedral/L05_0050A5F8.c b/src/overlays/l05_dark_cathedral/L05_0050A5F8.c
new file mode 100644
index 000000000..419a797d4
--- /dev/null
+++ b/src/overlays/l05_dark_cathedral/L05_0050A5F8.c
@@ -0,0 +1,68 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad0[0x70];
+    s32 x70;
+    s32 x74;
+    u8 pad78[0xC];
+    s16 n;
+    u8 pad86[0x16A];
+    u8 *mobys[1];
+} Arena;
+
+extern Arena D_0023C540;
+extern u8 *D_00363038[];
+extern s32 D_0021DE10;
+extern void func_L00_00596A28(s32, s32, s32, s32);
+extern void func_L00_00598118(s32);
+extern void func_L02_004E3248(void);
+
+void func_L05_0050A5F8(void) {
+    u8 *moby;
+    u8 *m;
+    u8 *q;
+    s32 i;
+    s32 j;
+    s32 id;
+
+    for (i = 0; i < D_0023C540.n; i++) {
+        moby = D_0023C540.mobys[i];
+        if (moby != NULL) {
+            id = *(s16 *)(moby + 0xBC);
+            if (id == 0x216A || id == 0x2691 || (id == 0x2429 && D_0021DE10 == 0x2574) || id == 0x20FD || id == 0x2703 || id == 0x2505) {
+                func_L00_00596A28(i, 0x96, 0, 0);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x216A || *(s16 *)(moby + 0xBC) == 0x2691) {
+                *(u16 *)(D_0023C540.mobys[i] + 0x74) |= 0x1000;
+            }
+            if (*(s16 *)(moby + 0xBC) == 0xA) {
+                m = D_0023C540.mobys[i];
+                if (D_0023C540.x70 == 2) {
+                    *(u16 *)(m + 0x74) |= 0x1000;
+                } else {
+                    *(u16 *)(m + 0x74) |= 0x1002;
+                }
+                func_L00_00596A28(i, 0x6E, 0x80306629, 0x8058B856);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x243D) {
+                func_L00_00596A28(i, 0x168, 0xC0808080, 0x80505050);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x247F || *(s16 *)(moby + 0xBC) == 0x24D9 || *(s16 *)(moby + 0xBC) == 0x24D5) {
+                func_L00_00596A28(i, 0x5A, 0xFFC0C0C0, 0xB0505050);
+            }
+        }
+    }
+    func_L02_004E3248();
+    if (D_0023C540.x70 == 0x2 && D_0023C540.x74 < 0xA0) {
+        func_L00_00598118(0);
+    }
+    if (D_0023C540.x70 == 0x3 && D_0023C540.x74 >= 0x65) {
+        func_L00_00598118(0);
+    }
+    func_L00_00598118(0);
+    for (j = 0, q = D_00363038[0]; j < 10; q = D_00363038[++j]) {
+        if (q != NULL) {
+            (*(u8 **)(q + 0x2EF0))[0x31] = 0;
+        }
+    }
+}
diff --git a/src/overlays/l13_maraxus_prison/L13_0046D2E8.c b/src/overlays/l13_maraxus_prison/L13_0046D2E8.c
new file mode 100644
index 000000000..877f29711
--- /dev/null
+++ b/src/overlays/l13_maraxus_prison/L13_0046D2E8.c
@@ -0,0 +1,63 @@
+/* cflags: -G0 -Wuninitialized */
+#include "common.h"
+typedef s32 M2C_UNK; typedef s8 M2C_UNK8; typedef s16 M2C_UNK16;
+typedef s32 M2C_UNK32; typedef s64 M2C_UNK64;
+typedef int solver_s128 __attribute__((mode(TI)));
+typedef unsigned int solver_u128 __attribute__((mode(TI)));
+typedef solver_s128 s128; typedef solver_u128 u128;
+#define M2C_FIELD(base, kind, offset) (*(kind)((u8 *)(base) + (offset)))
+#define M2C_R5900_PAND(a,b) __builtin_pand((u128)(a),(u128)(b))
+#define M2C_R5900_POR(a,b) __builtin_por((u128)(a),(u128)(b))
+#define M2C_R5900_PCPYLD(a,b) __builtin_pcpyld((u128)(a),(u128)(b))
+#define M2C_R5900_PEXTLW(a,b) __builtin_pextlw((u128)(a),(u128)(b))
+#define M2C_R5900_PEXTUW(a,b) __builtin_pextuw((u128)(a),(u128)(b))
+#define M2C_R5900_PROT3W(a) __builtin_prot3w((u128)(a))
+
+s32 func_0047BA40(s128, s32);
+s32 func_00556D90(s32, M2C_UNK, M2C_UNK);
+M2C_UNK func_0046D3E8(void *);
+M2C_UNK func_L13_0046D408(void *);
+M2C_UNK func_L13_0046D498(void *);
+extern void *D_00362E38[];
+
+void func_L13_0046D2E8(void *arg0) {
+    s32 temp_4;
+    s32 temp_5;
+    s32 var_17;
+    u8 temp_3;
+    void **var_16;
+    void *temp_19;
+    void *var_3;
+
+    temp_3 = M2C_FIELD(arg0, u8 *, 0x20);
+    temp_19 = M2C_FIELD(arg0, void **, 0xAC);
+    switch (temp_3) {
+    case 0:
+        func_0046D3E8(arg0);
+        return;
+    case 1:
+        var_17 = 9;
+        var_3 = D_00362E38[0];
+        var_16 = D_00362E38;
+        do {
+            if (var_3 != NULL) {
+                temp_5 = M2C_FIELD(temp_19, s32 *, 0x18);
+                if ((temp_5 >= 0) && (func_0047BA40(M2C_FIELD(var_3, s128 *, 0xA0), temp_5) != 0)) {
+                    func_L13_0046D408(arg0);
+                }
+            }
+            var_16 = (void **)((unsigned char *)(var_16) + (4));
+            var_17 = var_17 - 1;
+            var_3 = *var_16;
+        } while (var_17 >= 0);
+        break;
+    case 2:
+        temp_4 = M2C_FIELD(temp_19, s32 *, 0x1C);
+        if (temp_4 >= 0) {
+            if (func_00556D90(temp_4, -1, 0) == 0) {
+                func_L13_0046D498(arg0);
+            }
+        }
+        break;
+    }
+}
diff --git a/src/overlays/l15_control_level/L15_004D6FD0.c b/src/overlays/l15_control_level/L15_004D6FD0.c
new file mode 100644
index 000000000..0cb02f00d
--- /dev/null
+++ b/src/overlays/l15_control_level/L15_004D6FD0.c
@@ -0,0 +1,96 @@
+/* cflags: -Wuninitialized -Wa,-G0 */
+#include "common.h"
+typedef s32 M2C_UNK; typedef s8 M2C_UNK8; typedef s16 M2C_UNK16;
+typedef s32 M2C_UNK32; typedef s64 M2C_UNK64;
+typedef long long s128; typedef unsigned long long u128;
+#define M2C_FIELD(base, kind, offset) (*(kind)((u8 *)(base) + (offset)))
+#define M2C_R5900_PAND(a,b) __builtin_pand((u128)(a),(u128)(b))
+#define M2C_R5900_POR(a,b) __builtin_por((u128)(a),(u128)(b))
+#define M2C_R5900_PCPYLD(a,b) __builtin_pcpyld((u128)(a),(u128)(b))
+#define M2C_R5900_PEXTLW(a,b) __builtin_pextlw((u128)(a),(u128)(b))
+#define M2C_R5900_PEXTUW(a,b) __builtin_pextuw((u128)(a),(u128)(b))
+#define M2C_R5900_PROT3W(a) __builtin_prot3w((u128)(a))
+
+int func_00472590(int, int);
+void func_L01_0044AA78(void *, int, float);
+extern int D_00222694;
+int D_002226E0 = 0;
+extern s16 *D_00288B20[];
+void func_L15_004D6FD0(void *arg0, s32 arg1, s32 arg2) {
+  s32 temp_3;
+  s32 temp_4;
+  s16 *var_16;
+  u32 object;
+  s32 var_3;
+  void *temp_17;
+  temp_17 = *((void **) (((u8 *) arg0) + 0xAC));
+  temp_3 = *((s32 *) (((u8 *) temp_17) + 0x1E4));
+  if (arg1 != 0)
+  {
+    goto block_3;
+  }
+  if (temp_3 != 0)
+  {
+    goto block_4;
+  }
+  return;
+  block_3:
+  if (temp_3 == 3)
+  {
+    goto block_21;
+  }
+
+  block_4:
+  *((s32 *) (((u8 *) temp_17) + 0x1EC)) = 0;
+
+  if (arg2 == 0)
+  {
+    goto block_6;
+  }
+  var_3 = 4;
+  goto block_7;
+  block_6:
+  var_3 = func_00472590(1, 3);
+
+  block_7:
+  *((s32 *) (((u8 *) temp_17) + 0x1E8)) = var_3;
+
+  *((s32 *) (((u8 *) temp_17) + 0x1E4)) = (s32) ((arg1 == 0) ? (0) : (3));
+  if (arg2 == 0)
+  {
+    goto block_21;
+  }
+  var_16 = D_00288B20[*((s32 *) (((u8 *) temp_17) + 0x1D4))];
+  for (;;)
+  {
+    temp_4 = *((s32 *) (((u8 *) temp_17) + 0x1D4));
+    if ((temp_4 & 0xFF) == 0xFF)
+    {
+      break;
+    }
+    if (D_002226E0 < temp_4)
+    {
+      break;
+    }
+    if (var_16 == 0)
+    {
+      break;
+    }
+    if ((var_16[-1] < 0) && (var_16 != D_00288B20[temp_4]))
+    {
+      break;
+    }
+    object = ((u32) D_00222694) + ((((u32) (*((u16 *) var_16))) & 0x7FFF) << 8);
+    if (object == 0)
+    {
+      break;
+    }
+    var_16++;
+    func_L01_0044AA78((void *) object, *((s32 *) (((u8 *) temp_17) + 0x1E4)), 500.5f);
+  }
+
+  *((s32 *) (((u8 *) temp_17) + 0x1E8)) = 0;
+  block_21:
+  return;
+
+}
diff --git a/src/overlays/shared/L00_00593EC8.c b/src/overlays/shared/L00_00593EC8.c
new file mode 100644
index 000000000..5b4c2ec9a
--- /dev/null
+++ b/src/overlays/shared/L00_00593EC8.c
@@ -0,0 +1,28 @@
+#include "common.h"
+
+extern void func_001634A8(s32 repeat);
+extern u32 func_00163808(s32 a0, u32 a1, u32 a2, u32 a3, u32 a4, s32 a5, s32 a6);
+extern s32 *D_0021DDA4;
+extern u8 D_00223610[];
+extern u8 D_001C2040[];
+
+void func_L00_00593EC8(void) {
+    s32 mode = *D_0021DDA4;
+
+    if (mode == 3) {
+        u8 *s;
+        func_001634A8(1);
+        s = D_001C2040;
+        func_00163808(0, (u32)D_00223610, *(s32 *)(s + 0xBB08) + *(s32 *)(s + 0xB444),
+                      *(s32 *)(s + 0xBB0C), 0, 0, 0);
+    } else if (mode == 2) {
+        u8 *s;
+        func_001634A8(1);
+        s = D_001C2040;
+        func_00163808(0, (u32)D_00223610, *(s32 *)(s + 0xBA68) + *(s32 *)(s + 0xB444),
+                      *(s32 *)(s + 0xBA6C), 0, 0, 0);
+        func_001634A8(1);
+        func_00163808(0, (u32)(D_00223610 + 0x4800), *(s32 *)(s + 0xBA70) + *(s32 *)(s + 0xB444),
+                      *(s32 *)(s + 0xBA74), 0, 0, 0);
+    }
+}
diff --git a/src/overlays/shared/L00_00599710.c b/src/overlays/shared/L00_00599710.c
new file mode 100644
index 000000000..b8221d44a
--- /dev/null
+++ b/src/overlays/shared/L00_00599710.c
@@ -0,0 +1,62 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+extern s32 func_00596A28(s32, s32, u32, u32);
+extern s32 func_00598118(s32);
+extern s32 D_0021DE10;
+struct Type1 {
+    u8 f0[0x70];
+    s32 f70;
+    u8 f74[0x10];
+    s16 f84;
+};
+extern struct Type1 D_0023BE00[];
+extern u8 *D_00343E78[];
+#define ID(p) (*(s16 *)((p) + 0xbc))
+#define FLAGS(p) (*(u16 *)((p) + 0x74))
+
+void func_L00_00599710(void) {
+    s32 i;
+
+    u8 *m;
+    i = 0;
+    if (D_0023BE00[0].f84 > 0) {
+
+        do {
+            m = ((u8 **)((u8 *)D_0023BE00 + 0x1f0))[i];
+            if (m) {
+                if (ID(m) == 0x216a || ID(m) == 0x2691 ||
+                    (ID(m) == 0x2429 && D_0021DE10 == 0x2574) || ID(m) == 0x20fd ||
+                    ID(m) == 0x2703 || ID(m) == 0x2505)
+                    func_00596A28(i, 0x96, 0, 0);
+                if (ID(m) == 0x216a || ID(m) == 0x2691)
+                    FLAGS(((u8 **)((u8 *)D_0023BE00 + 0x1f0))[i]) |= 0x1000;
+                if (ID(m) == 10) {
+                    u8 *p = ((u8 **)((u8 *)D_0023BE00 + 0x1f0))[i];
+                    if (D_0023BE00[0].f70 == 2)
+                        FLAGS(p) |= 0x1000;
+                    else
+                        FLAGS(p) |= 0x1002;
+                    func_00596A28(i, 0x6E, 0x80306629, 0x8058b856);
+                }
+                if (ID(m) == 0x243d)
+                    func_00596A28(i, 0x168, 0xc0808080, 0x80505050);
+                if (ID(m) == 0x247f || ID(m) == 0x24d9 || ID(m) == 0x24d5)
+                    func_00596A28(i, 0x5A, 0xffc0c0c0, 0xb0505050);
+            }
+            i++;
+        } while (i < D_0023BE00[0].f84);
+    }
+    func_00598118(0);
+    {
+        u8 **p = D_00343E78;
+        s32 n = 9;
+        u8 *v = *p;
+        do {
+            p++;
+            n--;
+            if (v)
+                (*(u8 **)(v + 0x2ef0))[0x31] = 0;
+            v = *p;
+        } while (n >= 0);
+    }
+}
diff --git a/src/overlays/shared/L00_006027E8.c b/src/overlays/shared/L00_006027E8.c
new file mode 100644
index 000000000..644e65513
--- /dev/null
+++ b/src/overlays/shared/L00_006027E8.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_00222550;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_00222550 + 0x301C);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_00222550 + 0x3020);
+}
+s32 func_L00_006027E8(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_00222550 + 0x301C, input, 4);
+    input += 4;
+    *(u32 *)(D_00222550 + 0x3020) = (u32)func_0048B818((u32)count() << 3, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i << 3), input, 8);
+        input += 8;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L00_006028D0.c b/src/overlays/shared/L00_006028D0.c
new file mode 100644
index 000000000..23541d143
--- /dev/null
+++ b/src/overlays/shared/L00_006028D0.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_00222550;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_00222550 + 0x3024);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_00222550 + 0x3028);
+}
+s32 func_L00_006028D0(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_00222550 + 0x3024, input, 4);
+    input += 4;
+    *(u32 *)(D_00222550 + 0x3028) = (u32)func_0048B818((u32)count() << 3, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i << 3), input, 8);
+        input += 8;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L00_00602AA0.c b/src/overlays/shared/L00_00602AA0.c
new file mode 100644
index 000000000..5c06ea6ad
--- /dev/null
+++ b/src/overlays/shared/L00_00602AA0.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_00222550;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_00222550 + 0x3044);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_00222550 + 0x3048);
+}
+s32 func_L00_00602AA0(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_00222550 + 0x3044, input, 4);
+    input += 4;
+    *(u32 *)(D_00222550 + 0x3048) = (u32)func_0048B818((u32)count() << 3, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i << 3), input, 8);
+        input += 8;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L00_00602B88.c b/src/overlays/shared/L00_00602B88.c
new file mode 100644
index 000000000..57336c3b5
--- /dev/null
+++ b/src/overlays/shared/L00_00602B88.c
@@ -0,0 +1,23 @@
+#include "common.h"
+extern u8 *D_00222550;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline u32 *values(void)
+{
+    return (u32 *)*(u32 *)(D_00222550 + 0x3004);
+}
+s32 func_L00_00602B88(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 count;
+    s32 i;
+    func_00453718(&count, input, 4);
+    input += 4;
+    *(u32 *)(D_00222550 + 0x3004) = (u32)func_0048B818((u32)count << 2, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count; i++) {
+        func_00453718(values() + i, input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L00_00602C58.c b/src/overlays/shared/L00_00602C58.c
new file mode 100644
index 000000000..ad8477d45
--- /dev/null
+++ b/src/overlays/shared/L00_00602C58.c
@@ -0,0 +1,23 @@
+#include "common.h"
+extern u8 *D_00222550;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline u32 *values(void)
+{
+    return (u32 *)*(u32 *)(D_00222550 + 0x3008);
+}
+s32 func_L00_00602C58(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 count;
+    s32 i;
+    func_00453718(&count, input, 4);
+    input += 4;
+    *(u32 *)(D_00222550 + 0x3008) = (u32)func_0048B818((u32)count << 2, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count; i++) {
+        func_00453718(values() + i, input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L00_00602D28.c b/src/overlays/shared/L00_00602D28.c
new file mode 100644
index 000000000..04165f995
--- /dev/null
+++ b/src/overlays/shared/L00_00602D28.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_00222550;
+extern void func_005BCBF0(void *, const void *, u32);
+extern void *func_006025B0(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_00222550 + 0x305C);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_00222550 + 0x3060);
+}
+s32 func_L00_00602D28(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_005BCBF0(D_00222550 + 0x305C, input, 4);
+    input += 4;
+    *(u32 *)(D_00222550 + 0x3060) = (u32)func_006025B0((u32)count() * 4u, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_005BCBF0(values() + ((u32)i * 4u), input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L00_00602E10.c b/src/overlays/shared/L00_00602E10.c
new file mode 100644
index 000000000..d9288ca73
--- /dev/null
+++ b/src/overlays/shared/L00_00602E10.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_00222550;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_00222550 + 0x3064);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_00222550 + 0x3068);
+}
+s32 func_L00_00602E10(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_00222550 + 0x3064, input, 4);
+    input += 4;
+    *(u32 *)(D_00222550 + 0x3068) = (u32)func_0048B818((u32)count() * 4u, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i * 4u), input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L00_00602EF8.c b/src/overlays/shared/L00_00602EF8.c
new file mode 100644
index 000000000..a60af543f
--- /dev/null
+++ b/src/overlays/shared/L00_00602EF8.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_00222550;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_00222550 + 0x306C);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_00222550 + 0x3070);
+}
+s32 func_L00_00602EF8(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_00222550 + 0x306C, input, 4);
+    input += 4;
+    *(u32 *)(D_00222550 + 0x3070) = (u32)func_0048B818((u32)count() * 4u, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i * 4u), input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L00_00602FE0.c b/src/overlays/shared/L00_00602FE0.c
new file mode 100644
index 000000000..f0575330b
--- /dev/null
+++ b/src/overlays/shared/L00_00602FE0.c
@@ -0,0 +1,26 @@
+#include "common.h"
+extern u8 *D_00222550;
+extern void func_00453718(void *, const void *, u32);
+extern void *func_0048B818(u32, u8 **, const u8 *);
+static inline s32 count(void)
+{
+    return *(s32 *)(D_00222550 + 0x3074);
+}
+static inline u8 *values(void)
+{
+    return (u8 *)*(u32 *)(D_00222550 + 0x3078);
+}
+s32 func_L00_00602FE0(const u8 *input, u8 **cursor, const u8 *end)
+{
+    s32 i;
+    func_00453718(D_00222550 + 0x3074, input, 4);
+    input += 4;
+    *(u32 *)(D_00222550 + 0x3078) = (u32)func_0048B818((u32)count() * 4u, cursor, end);
+    if (!values())
+        return 1;
+    for (i = 0; i < count(); i++) {
+        func_00453718(values() + ((u32)i * 4u), input, 4);
+        input += 4;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L00_006282F0.c b/src/overlays/shared/L00_006282F0.c
new file mode 100644
index 000000000..b3c2c0e7b
--- /dev/null
+++ b/src/overlays/shared/L00_006282F0.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00223148[];
+extern Manager *func_005010E0(void);
+extern Allocator *func_005011A8(Manager *, s32);
+extern void func_L00_0069BEC8(s32);
+extern s32 func_L00_0069BED0(void);
+extern s32 func_004FF910(void *, u32);
+extern void *func_0015DB80(u32, void *);
+extern Object *func_0050EB00(void *);
+extern s32 func_005005A8(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00223148;
+    if (manager->table) {
+        return manager;
+    }
+    return func_005010E0();
+}
+
+s32 func_L00_006282F0(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_L00_0069BEC8(0x50);
+    size = func_L00_0069BED0();
+    if (entry != NULL && func_004FF910(entry, key) == 0) {
+        allocator = func_005011A8(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_0050EB00(func_0015DB80(0x50, block));
+            result = func_005005A8(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_005011A8(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/overlays/shared/L00_00644D18.c b/src/overlays/shared/L00_00644D18.c
new file mode 100644
index 000000000..45ff81f5e
--- /dev/null
+++ b/src/overlays/shared/L00_00644D18.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+typedef struct State {
+    u32 unknown;
+    s32 group;
+} State;
+
+extern s32 func_006294E0(s32 *group, s32 id);
+extern s32 func_0069D5D8(s32 handle, u32 resource);
+extern s32 func_0069D028(s32 handle, s32 visible);
+
+void func_L00_00644D18(State *state, s32 enabled, s32 count)
+{
+    func_0069D5D8(func_006294E0(&state->group, 8), 0x7546);
+    func_0069D5D8(func_006294E0(&state->group, 7), 0x7546);
+    func_0069D5D8(func_006294E0(&state->group, 6), 0x7546);
+    func_0069D5D8(func_006294E0(&state->group, 5), 0x7546);
+    func_0069D5D8(func_006294E0(&state->group, 4), 0x7546);
+
+    func_0069D028(func_006294E0(&state->group, 8), 0);
+    func_0069D028(func_006294E0(&state->group, 7), 0);
+    func_0069D028(func_006294E0(&state->group, 6), 0);
+    func_0069D028(func_006294E0(&state->group, 5), 0);
+    func_0069D028(func_006294E0(&state->group, 4), 0);
+
+    if (enabled) {
+        switch (count) {
+        case 5:
+            func_0069D028(func_006294E0(&state->group, 4), 1);
+        case 4:
+            func_0069D028(func_006294E0(&state->group, 5), 1);
+        case 3:
+            func_0069D028(func_006294E0(&state->group, 6), 1);
+        case 2:
+            func_0069D028(func_006294E0(&state->group, 7), 1);
+        case 1:
+            func_0069D028(func_006294E0(&state->group, 8), 1);
+        }
+    }
+}
diff --git a/src/overlays/shared/L00_0064DC68.c b/src/overlays/shared/L00_0064DC68.c
new file mode 100644
index 000000000..36715b4e9
--- /dev/null
+++ b/src/overlays/shared/L00_0064DC68.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+typedef struct State {
+    u32 unknown;
+    s32 group;
+} State;
+
+extern s32 func_004A1A60(s32 *group, s32 id);
+extern s32 func_L00_0069D5D8(s32 handle, u32 resource);
+extern s32 func_00504F68(s32 handle, s32 visible);
+
+void func_L00_0064DC68(State *state, s32 enabled, s32 count)
+{
+    func_L00_0069D5D8(func_004A1A60(&state->group, 8), 0x7546);
+    func_L00_0069D5D8(func_004A1A60(&state->group, 7), 0x7546);
+    func_L00_0069D5D8(func_004A1A60(&state->group, 6), 0x7546);
+    func_L00_0069D5D8(func_004A1A60(&state->group, 5), 0x7546);
+    func_L00_0069D5D8(func_004A1A60(&state->group, 4), 0x7546);
+
+    func_00504F68(func_004A1A60(&state->group, 8), 0);
+    func_00504F68(func_004A1A60(&state->group, 7), 0);
+    func_00504F68(func_004A1A60(&state->group, 6), 0);
+    func_00504F68(func_004A1A60(&state->group, 5), 0);
+    func_00504F68(func_004A1A60(&state->group, 4), 0);
+
+    if (enabled) {
+        switch (count) {
+        case 5:
+            func_00504F68(func_004A1A60(&state->group, 4), 1);
+        case 4:
+            func_00504F68(func_004A1A60(&state->group, 5), 1);
+        case 3:
+            func_00504F68(func_004A1A60(&state->group, 6), 1);
+        case 2:
+            func_00504F68(func_004A1A60(&state->group, 7), 1);
+        case 1:
+            func_00504F68(func_004A1A60(&state->group, 8), 1);
+        }
+    }
+}
diff --git a/src/overlays/shared/L00_00666CE8.c b/src/overlays/shared/L00_00666CE8.c
new file mode 100644
index 000000000..ae4440971
--- /dev/null
+++ b/src/overlays/shared/L00_00666CE8.c
@@ -0,0 +1,34 @@
+#include "common.h"
+
+extern s32 func_L00_006688C8(s32);
+extern void func_L00_00679408(void);
+extern s32 *D_00222D68;
+extern s32 D_00222D70;
+extern s32 *D_00222EE0;
+extern s32 D_0021DA30;
+
+void func_L00_00666CE8(void) {
+    s32 *t;
+    s32 n;
+
+    t = D_00222EE0;
+    D_00222EE0 = t + 4;
+    D_00222D68[0] = 0x20000000;
+    D_00222D68[1] = (s32)D_00222EE0;
+    D_00222D68[2] = 0;
+    D_00222D68[3] = 0;
+    n = func_L00_006688C8(D_0021DA30);
+    func_L00_00679408();
+    if (D_00222D70 < n) {
+        D_00222D70 = n;
+    }
+    D_00222EE0[0] = 0x20000000;
+    D_00222EE0[1] = (s32)(D_00222D68 + 4);
+    D_00222EE0[2] = 0;
+    D_00222EE0[3] = 0;
+    D_00222EE0 += 4;
+    t[0] = 0x20000000;
+    t[1] = (s32)D_00222EE0;
+    t[2] = 0;
+    t[3] = 0;
+}
diff --git a/src/overlays/shared/L00_0069C6A8.c b/src/overlays/shared/L00_0069C6A8.c
new file mode 100644
index 000000000..a4124674b
--- /dev/null
+++ b/src/overlays/shared/L00_0069C6A8.c
@@ -0,0 +1,52 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct Vtable {
+    void *unused[3];
+    u32 (*type)(Object *);
+    void *f10;
+    s32 (*supports)(Object *, u32);
+} Vtable;
+struct Object {
+    s32 f0, f4;
+    Vtable *vtable;
+};
+typedef struct {
+    s32 f0;
+    void *context;
+} Manager;
+extern Manager D_00223148[];
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, s32);
+extern u32 D_002203D0;
+static inline Object *resolve(s32 handle)
+{
+    Manager *m;
+    Object *obj;
+    void *world;
+    if (D_00223148[0].context)
+        m = D_00223148;
+    else
+        m = func_005010E0();
+    world = 0;
+    if (m->context)
+        world = *(void **)((u32)m->context + ((u32) * (s32 *)((char *)m->context + 0x14) << 2));
+    obj = func_005005E8(world, handle);
+    if (obj && obj->vtable->supports(obj, D_002203D0))
+        return obj;
+    return 0;
+}
+typedef s32 (*Callback)(Object *, f32, f32);
+extern char D_00343E38[];
+extern Callback func_L00_0069FF70(void *, u32);
+s32 func_L00_0069C6A8(s32 handle, f32 a, f32 b)
+{
+    s32 result = 0;
+    Object *obj = resolve(handle);
+    if (obj) {
+        u32 type = obj->vtable->type(obj);
+        Callback callback = func_L00_0069FF70(D_00343E38, type);
+        if (callback)
+            result = callback(obj, a, b);
+    }
+    return result;
+}
diff --git a/src/overlays/shared/L00_0069C890.c b/src/overlays/shared/L00_0069C890.c
new file mode 100644
index 000000000..d5e3fe5e1
--- /dev/null
+++ b/src/overlays/shared/L00_0069C890.c
@@ -0,0 +1,52 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct Vtable {
+    void *unused[3];
+    u32 (*type)(Object *);
+    void *f10;
+    s32 (*supports)(Object *, u32);
+} Vtable;
+struct Object {
+    s32 f0, f4;
+    Vtable *vtable;
+};
+typedef struct {
+    s32 f0;
+    void *context;
+} Manager;
+extern Manager D_00223148[];
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, s32);
+extern u32 D_002203D0;
+static inline Object *resolve(s32 handle)
+{
+    Manager *m;
+    Object *obj;
+    void *world;
+    if (D_00223148[0].context)
+        m = D_00223148;
+    else
+        m = func_005010E0();
+    world = 0;
+    if (m->context)
+        world = *(void **)((u32)m->context + ((u32) * (s32 *)((char *)m->context + 0x14) << 2));
+    obj = func_005005E8(world, handle);
+    if (obj && obj->vtable->supports(obj, D_002203D0))
+        return obj;
+    return 0;
+}
+typedef s32 (*Callback)(Object *, f32, f32);
+extern char D_00343DB8[];
+extern Callback func_L00_0069FF70(void *, u32);
+s32 func_L00_0069C890(s32 handle, f32 a, f32 b)
+{
+    s32 result = 0;
+    Object *obj = resolve(handle);
+    if (obj) {
+        u32 type = obj->vtable->type(obj);
+        Callback callback = func_L00_0069FF70(D_00343DB8, type);
+        if (callback)
+            result = callback(obj, a, b);
+    }
+    return result;
+}
diff --git a/src/overlays/shared/L00_0069D7A8.c b/src/overlays/shared/L00_0069D7A8.c
new file mode 100644
index 000000000..47d6b6fdc
--- /dev/null
+++ b/src/overlays/shared/L00_0069D7A8.c
@@ -0,0 +1,61 @@
+#include "common.h"
+typedef struct Object Object;
+typedef struct {
+    char pad[0xC];
+    u32 (*getType)(Object *);
+    s32 pad10;
+    s32 (*isType)(Object *, u32);
+} VTable;
+struct Object {
+    char pad[8];
+    VTable *vtable;
+};
+
+typedef struct {
+    s32 pad;
+    char *table;
+} Manager;
+extern Manager D_00223148[];
+extern u32 D_002203D0;
+extern Manager *func_005010E0(void);
+extern Object *func_005005E8(void *, u32);
+typedef s32 (*Callback)(Object *, s32, s32, s32, s32);
+extern Callback func_L00_006A04E0(void *, u32);
+static inline Manager *getManager(void)
+{
+    Manager *p = D_00223148;
+    if (p->table)
+        return p;
+    return func_005010E0();
+}
+static inline Object *valid(Object *p)
+{
+    if (p && p->vtable->isType(p, D_002203D0))
+        return p;
+    return 0;
+}
+static inline Object *getTyped(u32 id)
+{
+    Manager *m = getManager();
+    char *state = m->table;
+    void *table = 0;
+    if (state)
+        table = *(void **)(state + (*(s32 *)(state + 0x14) << 2));
+    return valid(func_005005E8(table, id));
+}
+extern char D_00343CE0[];
+static inline Callback handler(u32 kind)
+{
+    return func_L00_006A04E0(D_00343CE0, kind);
+}
+s32 func_L00_0069D7A8(u32 id, s32 arg1, s32 arg2, s32 arg3, s32 arg4)
+{
+    s32 result = 0;
+    Object *p = getTyped(id);
+    if (p) {
+        Callback callback = handler(p->vtable->getType(p));
+        if (callback)
+            result = callback(p, arg1, arg2, arg3, arg4);
+    }
+    return result;
+}
diff --git a/src/overlays/shared/L00_006A06A0.c b/src/overlays/shared/L00_006A06A0.c
new file mode 100644
index 000000000..c3ecc5559
--- /dev/null
+++ b/src/overlays/shared/L00_006A06A0.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00223148[];
+extern Manager *func_005010E0(void);
+extern Allocator *func_005011A8(Manager *, s32);
+extern void func_L00_0069BEC8(s32);
+extern s32 func_L00_0069BED0(void);
+extern s32 func_004FF910(void *, u32);
+extern void *func_0015DB80(u32, void *);
+extern Object *func_005105A0(void *);
+extern s32 func_005005A8(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00223148;
+    if (manager->table) {
+        return manager;
+    }
+    return func_005010E0();
+}
+
+s32 func_L00_006A06A0(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_L00_0069BEC8(0x50);
+    size = func_L00_0069BED0();
+    if (entry != NULL && func_004FF910(entry, key) == 0) {
+        allocator = func_005011A8(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_005105A0(func_0015DB80(0x50, block));
+            result = func_005005A8(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_005011A8(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/overlays/shared/L00_006E8D78.c b/src/overlays/shared/L00_006E8D78.c
new file mode 100644
index 000000000..6602602ef
--- /dev/null
+++ b/src/overlays/shared/L00_006E8D78.c
@@ -0,0 +1,13 @@
+#include "common.h"
+
+extern void func_00453608(void *, s32, s32);
+extern void *func_L00_006EBB80(u8 *p);
+extern u8 D_004B5A10[];
+
+void func_L00_006E8D78(u8 *p) {
+    func_00453608(p, 0, 0x31f0);
+    func_L00_006EBB80(p);
+    *(u8 **)(p + 0x14) = D_004B5A10;
+    *(u8 *)(p + 0x266d) = 1;
+    *(u8 *)(p + 0x31cf) = 5;
+}
diff --git a/src/overlays/shared/L01_003C9A68.c b/src/overlays/shared/L01_003C9A68.c
new file mode 100644
index 000000000..d095f83b9
--- /dev/null
+++ b/src/overlays/shared/L01_003C9A68.c
@@ -0,0 +1,64 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+#define FIELD(base, type, offset) (*(type *)((u8 *)(base) + (offset)))
+void *func_0046B930(s32, s32);
+void func_0047B9B8(void *, s32);
+void func_L01_003C9930(void *);
+void func_L01_003C9CF0(void *);
+extern s32 D_0021DE10;
+extern s16 D_003BAB60[];
+
+void *func_L01_003C9A68(s32 arg0, u8 arg1, u8 arg2, u8 arg3, u8 arg4, s32 arg5) {
+    s32 index;
+    void *actor;
+    void *data;
+    void *second;
+    if (arg0 == -1)
+        goto failed;
+    index = D_0021DE10 % 20;
+    if (arg0 >= 26) {
+        if (arg0 < D_003BAB60[index])
+            return 0;
+        if (arg0 > D_003BAB60[index + 1])
+            return 0;
+    }
+    actor = func_0046B930(3950, 144);
+    if (!actor) {
+    failed:
+        return 0;
+    }
+    data = FIELD(actor, void *, 0xAC);
+    func_0047B9B8(actor, 0);
+    FIELD(data, s32, 0x6C) = arg0;
+    FIELD(data, u8, 0x71) = arg1;
+    FIELD(data, u8, 0x72) = arg2;
+    FIELD(data, u8, 0x7C) = arg3;
+    FIELD(data, u8, 0x7D) = arg4;
+    FIELD(data, u8, 0x70) = 1;
+    FIELD(data, s32, 0x74) = -1;
+    FIELD(data, u8, 0x7F) = 0;
+    FIELD(data, u8, 0x7E) = 0;
+    FIELD(data, u8, 0x80) = 0;
+    FIELD(data, s8, 0x73) = -1;
+    FIELD(data, s32, 0x88) = -1;
+    FIELD(data, s32, 0x78) = -1;
+    FIELD(data, void *, 0x84) = 0;
+    if (arg5 != -1) {
+        second = func_0046B930(3950, 144);
+        FIELD(data, void *, 0x84) = second;
+        if (second) {
+            data = FIELD(second, void *, 0xAC);
+            func_0047B9B8(second, 0);
+            FIELD(data, u8, 0x70) = 1;
+            FIELD(data, void *, 0x84) = 0;
+            FIELD(data, u8, 0x7F) = 0;
+            FIELD(data, u8, 0x7E) = 0;
+            FIELD(data, u8, 0x80) = 0;
+            FIELD(data, s32, 0x78) = FIELD(data, s32, 0x88) = FIELD(data, s8, 0x73) = -1;
+            FIELD(data, s32, 0x6C) = arg5;
+        }
+    }
+    func_L01_003C9930(actor);
+    func_L01_003C9CF0(actor);
+    return actor;
+}
diff --git a/src/overlays/shared/L01_003DAF28.c b/src/overlays/shared/L01_003DAF28.c
new file mode 100644
index 000000000..72e9050a4
--- /dev/null
+++ b/src/overlays/shared/L01_003DAF28.c
@@ -0,0 +1,62 @@
+#include "common.h"
+
+typedef unsigned int Quadword __attribute__((mode(TI)));
+extern char *func_0046B930(s32 classId, s32 privateSize);
+extern void func_004706F0(void *object);
+extern void func_00476C38(void *object);
+
+char *func_L01_003DAF28(const char *descriptor, const Quadword *position, u32 value, const Quadword *optional)
+{
+    char *object = func_0046B930(0x27F, 0x80);
+    if (object != 0) {
+        char *state;
+        u8 mode;
+        *(u8 *)(object + 0x30) = 0xFF;
+        *(u8 *)(object + 0x31) = 1;
+        *(u16 *)(object + 0x34) |= 1;
+        *(u8 *)(object + 0x20) = 0;
+        *(u8 *)(object + 0x67) = 0;
+        state = *(char **)(object + 0xAC);
+        *(Quadword *)(object + 0x10) = *position;
+        *(Quadword *)state = optional != 0 ? *optional : *(const Quadword *)descriptor;
+        *(u32 *)(state + 0x20) = value;
+        *(u16 *)(object + 0x32) = *(const u8 *)(descriptor + 0x3C);
+        *(u8 *)(state + 0x24) = *(const u8 *)(descriptor + 0x10);
+        *(u8 *)(state + 0x25) = *(const u8 *)(descriptor + 0x11);
+        *(u8 *)(state + 0x26) = *(const u8 *)(descriptor + 0x12);
+        *(u8 *)(state + 0x27) = *(const u8 *)(descriptor + 0x13);
+        *(u8 *)(state + 0x28) = *(const u8 *)(descriptor + 0x14);
+        *(u8 *)(state + 0x29) = *(const u8 *)(descriptor + 0x15);
+        *(u8 *)(state + 0x68) = *(const u8 *)(descriptor + 0x3D);
+        *(u16 *)(state + 0x6C) = *(const u16 *)(descriptor + 0x40);
+        *(u8 *)(state + 0x2A) = *(const u8 *)(descriptor + 0x16);
+        *(u8 *)(state + 0x2B) = *(const u8 *)(descriptor + 0x17);
+        *(u8 *)(state + 0x2C) = *(const u8 *)(descriptor + 0x18);
+        *(u8 *)(state + 0x2D) = *(const u8 *)(descriptor + 0x19);
+        *(u8 *)(state + 0x2E) = *(const u8 *)(descriptor + 0x1A);
+        *(u8 *)(state + 0x69) = *(const u8 *)(descriptor + 0x3E);
+        *(u16 *)(state + 0x6E) = *(const u16 *)(descriptor + 0x42);
+        *(u8 *)(state + 0x2F) = *(const u8 *)(descriptor + 0x1B);
+        *(u8 *)(state + 0x30) = *(const u8 *)(descriptor + 0x1C);
+        *(u8 *)(state + 0x31) = *(const u8 *)(descriptor + 0x1D);
+        *(u8 *)(state + 0x32) = *(const u8 *)(descriptor + 0x1E);
+        *(u8 *)(state + 0x33) = *(const u8 *)(descriptor + 0x1F);
+        *(u8 *)(state + 0x6A) = *(const u8 *)(descriptor + 0x3F);
+        *(u16 *)(state + 0x70) = *(const u16 *)(descriptor + 0x44);
+        *(f32 *)(state + 0x34) = *(const f32 *)(descriptor + 0x20);
+        *(f32 *)(state + 0x38) = *(const f32 *)(descriptor + 0x24);
+        *(f32 *)(state + 0x3C) = *(const f32 *)(descriptor + 0x28);
+        *(f32 *)(state + 0x40) = *(const f32 *)(descriptor + 0x2C);
+        *(f32 *)(state + 0x44) = *(const f32 *)(descriptor + 0x30);
+        *(u8 *)(state + 0x6B) = *(const u8 *)(descriptor + 0x48);
+        *(u16 *)(state + 0x72) = *(const u16 *)(descriptor + 0x46);
+        *(u32 *)(state + 0x48) = *(const u32 *)(descriptor + 0x34);
+        *(u32 *)(state + 0x4C) = *(const u32 *)(descriptor + 0x38);
+        mode = *(const u8 *)(descriptor + 0x49);
+        *(s32 *)(state + 0x64) = -1;
+        *(u8 *)(state + 0x1C) = mode;
+        func_004706F0(object);
+        func_00476C38(object);
+    }
+    return object;
+}
diff --git a/src/overlays/shared/L01_003EE950.c b/src/overlays/shared/L01_003EE950.c
new file mode 100644
index 000000000..9689c1a23
--- /dev/null
+++ b/src/overlays/shared/L01_003EE950.c
@@ -0,0 +1,34 @@
+#include "common.h"
+s32 func_L01_0056B748(void *object);
+s32 func_L01_0056D480(void *extension, void *object);
+f32 func_L01_003EE950(void *object)
+{
+    f32 result;
+    s32 count;
+    s32 total;
+    void *extension;
+    void *node;
+
+    count = 0;
+    extension = *(void **)((u8 *)object + 0xAC);
+    node = *(void **)((u8 *)extension + 0x3F0);
+    total = 0;
+    if (node != NULL) {
+        do {
+            total = (s32)((u32)total + 2U);
+            if (func_L01_0056B748(node) != 0) {
+                count = (s32)((u32)count + 1U);
+            }
+            if (func_L01_0056D480(extension, node) != 0) {
+                count = (s32)((u32)count + 1U);
+            }
+            node = *(void **)((u8 *)node + 0x1AC);
+        } while (node != NULL);
+    }
+    if (total != 0) {
+        result = (f32)count / (f32)total;
+    } else {
+        result = 1.0f;
+    }
+    return result;
+}
diff --git a/src/overlays/shared/L01_00412848.c b/src/overlays/shared/L01_00412848.c
new file mode 100644
index 000000000..f1f33e5ac
--- /dev/null
+++ b/src/overlays/shared/L01_00412848.c
@@ -0,0 +1,31 @@
+/* cflags: -O2 -G8 -Wa,-G0 -Wuninitialized */
+#include "common.h"
+typedef unsigned long long u128;
+extern int func_0054A7E0(int, int);
+extern unsigned char *func_00548D28(int, int);
+extern int func_0054A788(int, int, int);
+extern void func_004742D8(void *, u128, int, int, float, float, float, int, int);
+
+void func_L01_00412848(void *actor, u128 position, float scale) {
+    char *data = *(char **)((char *)actor + 0xAC);
+    int flags = 0x801;
+    unsigned char count;
+    int extra;
+    if (func_0054A7E0(*(int *)(*(char **)(data + 0x40) + 0x26E4), 5) == 3)
+        flags = 0x800801;
+    if (func_0054A7E0(*(int *)(*(char **)(data + 0x40) + 0x26E4), 5) == 7)
+        flags |= 0x80;
+    if (func_0054A7E0(*(int *)(*(char **)(data + 0x40) + 0x26E4), 5) == 8)
+        flags |= 0x40;
+    if (func_0054A7E0(*(int *)(*(char **)(data + 0x40) + 0x26E4), 5) == 6)
+        flags |= 0x100;
+    if (func_0054A7E0(*(int *)(*(char **)(data + 0x40) + 0x26E4), 5) == 5)
+        flags |= 0x400;
+    count = func_00548D28(5, 0)[0x2F];
+    extra = func_0054A788(*(int *)(*(char **)(data + 0x40) + 0x26E4), 5, 4);
+    if (extra > 0) {
+        flags |= 0x20;
+        count += extra;
+    }
+    func_004742D8(actor, position, flags, 1, .3f, scale, (float)(extra + 1), count, 0);
+}
diff --git a/src/overlays/shared/L01_00431B38.c b/src/overlays/shared/L01_00431B38.c
new file mode 100644
index 000000000..649970666
--- /dev/null
+++ b/src/overlays/shared/L01_00431B38.c
@@ -0,0 +1,57 @@
+#include "common.h"
+
+typedef int u128 __attribute__((mode(TI)));
+
+extern u8 *func_005869E0(s32, s32);
+extern void func_00587A98(u8 *, s32, u8 *);
+extern void func_00591BD8(u8 *, s32, s32);
+extern void func_00587930(u8 *, s32, u128 *);
+extern void func_00596470(u128 *, u8 *);
+
+s32 func_L01_00431B38(u8 *owner, s32 joint, s32 bone, s32 flags, f32 scale) {
+    u128 mtx[4];
+    u8 pos[0x10];
+    u8 *moby = func_005869E0(0x200F, 0x10);
+    u8 *v1;
+    u8 *v2;
+    u8 *o;
+    f32 f;
+    u128 *m;
+
+    if (moby == NULL) {
+        return 0;
+    }
+    if (owner == NULL) {
+        return 0;
+    }
+    v1 = *(u8 **)(moby + 0xAC);
+    if (flags & 8) {
+        v1[0xA] = 1;
+    } else {
+        v1[0xA] = 0;
+    }
+    func_00587A98(owner, v1[8], pos);
+    v2 = *(u8 **)(moby + 0xAC);
+    *(u8 **)(moby + 0xB8) = owner;
+    moby[0x30] = 0xFF;
+    *(s16 *)(moby + 0x32) = 0xFF;
+    v2[8] = joint;
+    o = *(u8 **)(moby + 0xB8);
+    if (o != NULL && o[0x20] != 0xFE && o[0x20] != 0xFD) {
+        f = *(f32 *)(o + 0x70) / *(f32 *)(*(u8 **)(o + 0x24) + 0x24);
+    } else {
+        f = 1.0f;
+    }
+    *(f32 *)(moby + 0x70) = scale * f * 0.4f;
+    *(s32 *)(v2 + 0) = flags;
+    func_00591BD8(moby, 0, -1);
+    *(s16 *)(v2 + 4) = 0x2D;
+    v1[9] = bone;
+    func_00587930(*(u8 **)(moby + 0xB8), (s8)bone, mtx);
+    func_00596470(mtx, moby + 0xF0);
+    m = (u128 *)(moby + 0xC0);
+    m[0] = mtx[0];
+    m[1] = mtx[1];
+    m[2] = mtx[2];
+    return 1;
+}
diff --git a/src/overlays/shared/L01_00450348.c b/src/overlays/shared/L01_00450348.c
new file mode 100644
index 000000000..fd0d3c57c
--- /dev/null
+++ b/src/overlays/shared/L01_00450348.c
@@ -0,0 +1,29 @@
+#include "common.h"
+
+void func_00453718(void *destination, const void *source, u32 bytes);
+f32 func_004756D0(f32 first, f32 last, f32 fraction);
+s32 func_004756A8(s32 first, s32 last, f32 fraction);
+void func_L01_00450348(void *arg0, void *arg1, void *arg2, f32 fparg0)
+{
+  if ((arg1 == arg2) || (fparg0 <= 0.0f))
+  {
+    func_00453718(arg0, arg1, 0x20U);
+  }
+  else
+    if (fparg0 >= 1.0f)
+  {
+    func_00453718(arg0, arg2, 0x20U);
+  }
+  else
+  {
+    *((f32 *) (((s8 *) arg0) + 0)) = func_004756D0(*((f32 *) (((s8 *) arg1) + 0)), *((f32 *) (((s8 *) arg2) + 0)), fparg0);
+    *((f32 *) (((s8 *) arg0) + 4)) = func_004756D0(*((f32 *) (((s8 *) arg1) + 4)), *((f32 *) (((s8 *) arg2) + 4)), fparg0);
+    *((f32 *) (((s8 *) arg0) + 8)) = func_004756D0(*((f32 *) (((s8 *) arg1) + 8)), *((f32 *) (((s8 *) arg2) + 8)), fparg0);
+    *((f32 *) (((s8 *) arg0) + 0xC)) = func_004756D0(*((f32 *) (((s8 *) arg1) + 0xC)), *((f32 *) (((s8 *) arg2) + 0xC)), fparg0);
+    *((f32 *) (((s8 *) arg0) + 0x10)) = func_004756D0(*((f32 *) (((s8 *) arg1) + 0x10)), *((f32 *) (((s8 *) arg2) + 0x10)), fparg0);
+    *((s8 *) (((s8 *) arg0) + 0x14)) = func_004756A8(*((u8 *) (((s8 *) arg1) + 0x14)), *((u8 *) (((s8 *) arg2) + 0x14)), fparg0);
+    *((s8 *) (((s8 *) arg0) + 0x15)) = func_004756A8(*((u8 *) (((s8 *) arg1) + 0x15)), *((u8 *) (((s8 *) arg2) + 0x15)), fparg0);
+    *((s8 *) (((s8 *) arg0) + 0x16)) = func_004756A8(*((u8 *) (((s8 *) arg1) + 0x16)), *((u8 *) (((s8 *) arg2) + 0x16)), fparg0);
+    *((s8 *) (((s8 *) arg0) + 0x17)) = func_004756A8(*((u8 *) (((s8 *) arg1) + 0x17)), *((u8 *) (((s8 *) arg2) + 0x17)), fparg0);
+  }
+}
diff --git a/src/overlays/shared/L01_00452D40.c b/src/overlays/shared/L01_00452D40.c
new file mode 100644
index 000000000..13f5fb244
--- /dev/null
+++ b/src/overlays/shared/L01_00452D40.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+extern s32 func_004534D0(void *);
+extern void func_0046BDD0(void *);
+extern void func_00473A88(void *, s32, s32);
+extern void func_L01_00452E10(void *);
+extern void func_L01_00453100(void *);
+extern void func_L01_00453608(void *);
+
+void func_L01_00452D40(u8 *arg0) {
+    u8 *vars = *(u8 **)(arg0 + 0xAC);
+
+    if (vars != NULL && *(s32 *)(vars + 0x10) != 0) {
+        switch (arg0[0x20]) {
+        case 0: {
+            s32 first;
+            u8 flags = arg0[0xBE];
+            if ((flags ^ 1) & 1) {
+                first = 1;
+                arg0[0xBE] = flags | 1;
+            } else {
+                first = 0;
+            }
+            if (first != 0) {
+                *(s32 *)(vars + 0x14) = 0x3C;
+            }
+            func_L01_00452E10(arg0);
+            func_L01_00453608(arg0);
+            func_L01_00453100(arg0);
+            if (func_004534D0(vars + 0x14) != 0) {
+                func_00473A88(arg0, 1, -1);
+            }
+            break;
+        }
+        case 1:
+            func_0046BDD0(arg0);
+            break;
+        }
+    }
+}
diff --git a/src/overlays/shared/L01_00453820.c b/src/overlays/shared/L01_00453820.c
new file mode 100644
index 000000000..6d4ee5b41
--- /dev/null
+++ b/src/overlays/shared/L01_00453820.c
@@ -0,0 +1,53 @@
+#include "common.h"
+
+typedef struct V_00453820 {
+    u8 pad0[0x170];
+    s32 unk170;
+    s32 unk174;
+    s32 unk178;
+    u8 pad17C[0x19C - 0x17C];
+    s32 unk19C;
+    u8 pad1A0[0x1DC - 0x1A0];
+    u8 unk1DC;
+} V_00453820;
+
+typedef struct A_00453820 {
+    u8 pad0[0xAC];
+    V_00453820 *unkAC;
+} A_00453820;
+
+extern s32 func_L01_00453750(s32);
+extern s32 func_L01_004537F8(s32);
+extern s32 func_L01_0056A718(V_00453820 *, s32);
+
+f32 func_L01_00453820(A_00453820 *arg0) {
+    V_00453820 *v;
+    s32 total;
+    s32 good;
+    s32 bad;
+    s32 n;
+
+    good = 0;
+    total = 0;
+    v = arg0->unkAC;
+    bad = 0;
+    if (v == NULL || v->unk19C > 0 || v->unk1DC == 0) {
+        return 0.0f;
+    }
+    if (v->unk174 != 0) {
+        good = func_L01_004537F8(v->unk178);
+        total = func_L01_004537F8(v->unk174);
+        bad = func_L01_0056A718(v, -1);
+    }
+    if (v->unk170 != -1) {
+        n = func_L01_00453750(v->unk170);
+        total += n;
+        if (v->unk1DC != 0) {
+            good += n;
+        }
+    }
+    if (total <= 0) {
+        return 1.0f;
+    }
+    return (2.0f * good - bad) / (2.0f * total);
+}
diff --git a/src/overlays/shared/L01_0045BF60.c b/src/overlays/shared/L01_0045BF60.c
new file mode 100644
index 000000000..c9b2fb244
--- /dev/null
+++ b/src/overlays/shared/L01_0045BF60.c
@@ -0,0 +1,11 @@
+/* cflags: -mno-split-addresses */
+#include "common.h"
+
+extern s32 func_00550790(void *, void *, void *, void *, void *, s32, s32);
+extern u8 D_00222B20[];
+
+void func_L01_0045BF60(void *arg0) {
+    u8 *linked = *(u8 **)((u8 *)arg0 + 0xAC);
+    func_00550790(D_00222B20, arg0, (u8 *)arg0 + 0x10, (u8 *)arg0 + 0xF0, linked + 0x5F0, 1, 0);
+    *(s16 *)(linked + 0x60E) = 0x78;
+}
diff --git a/src/overlays/shared/L01_0045D4F0.c b/src/overlays/shared/L01_0045D4F0.c
new file mode 100644
index 000000000..0c88e1e24
--- /dev/null
+++ b/src/overlays/shared/L01_0045D4F0.c
@@ -0,0 +1,21 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+extern s64 func_L01_0045C0A0(void *object);
+
+u32 func_L01_0045D4F0(void *object)
+{
+    u32 value;
+    u32 result;
+    u8 disabled;
+
+    value = (u32)*(u8 **)((u8 *)object + 0xAC);
+    disabled = ((u8 *)value)[0x458];
+    result = 0;
+    if (disabled == 0) {
+        value = func_L01_0045C0A0(object) != 0;
+        result = value;
+    }
+    value = result;
+    return value;
+}
diff --git a/src/overlays/shared/L01_00469C88.c b/src/overlays/shared/L01_00469C88.c
new file mode 100644
index 000000000..6f2ed4397
--- /dev/null
+++ b/src/overlays/shared/L01_00469C88.c
@@ -0,0 +1,21 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+extern s64 func_L01_004697A0(void *object);
+
+u32 func_L01_00469C88(void *object)
+{
+    u32 value;
+    u32 result;
+    u8 disabled;
+
+    value = (u32)*(u8 **)((u8 *)object + 0xAC);
+    disabled = ((u8 *)value)[0x458];
+    result = 0;
+    if (disabled == 0) {
+        value = func_L01_004697A0(object) != 0;
+        result = value;
+    }
+    value = result;
+    return value;
+}
diff --git a/src/overlays/shared/L01_0048DF40.c b/src/overlays/shared/L01_0048DF40.c
new file mode 100644
index 000000000..cf958949b
--- /dev/null
+++ b/src/overlays/shared/L01_0048DF40.c
@@ -0,0 +1,53 @@
+#include "common.h"
+
+typedef int u128 __attribute__((mode(TI)));
+
+extern f32 *func_00476690(void *);
+extern s32 func_00476660(void *);
+extern s32 func_L01_005AE158(void *);
+extern void func_L01_005A24D0(void *, s32);
+extern void func_00484710(void *, s32, s32);
+extern void func_00473A88(void *, s32, s32);
+extern void func_L00_005F15B8(void *);
+extern void func_005A85F8(void *, s32, s32);
+extern s32 func_L01_005A2F40(void *, void *);
+extern void func_L01_005A1B38(void *);
+extern void func_004771B0(void *, s32);
+
+s32 func_L01_0048DF40(u8 *arg0, u8 *arg1) {
+    f32 *value;
+    f32 old;
+    u8 *obj;
+
+    if (*(u8 **)(arg1 + 0x170) == NULL) {
+        return arg0[0x20] != 1;
+    }
+    value = func_00476690(*(u8 **)(arg1 + 0x170));
+    if (value == NULL) {
+        return 1;
+    }
+    if (func_00476660(*(u8 **)(arg1 + 0x170)) == 0) {
+        return 1;
+    }
+    old = *value;
+    if (func_L01_005AE158(*(u8 **)(arg1 + 0x170)) != 0 || *value < old) {
+        func_L01_005A24D0(arg0, 0xF0);
+    }
+    if (*value <= 0.0f) {
+        func_00484710(*(u8 **)(arg1 + 0x170), -1, 0);
+        func_00473A88(arg0, 5, 4);
+    }
+    obj = *(u8 **)(arg1 + 0x170);
+    if (((*(u64 *)(obj + 0x30) & ((u64)0x8208 << 29)) != ((u64)0x8200 << 23) || *(s32 *)(obj + 0x98) != 0) &&
+        *value > 0.0f) {
+        func_L00_005F15B8(obj);
+        func_005A85F8(arg0, 5, -1);
+    }
+    if (*(s32 *)(arg1 + 0x60) != 0 && func_L01_005A2F40(arg0, arg1 + 0x50) != 0) {
+        arg1[0x1D6] = 1;
+        *(u128 *)(arg1 + 0xD60) = *(u128 *)(arg1 + 0x50);
+    }
+    func_L01_005A1B38(arg0);
+    func_004771B0(*(u8 **)(arg1 + 0x170), 0);
+    return 0;
+}
diff --git a/src/overlays/shared/L01_0048F9F8.c b/src/overlays/shared/L01_0048F9F8.c
new file mode 100644
index 000000000..382af4817
--- /dev/null
+++ b/src/overlays/shared/L01_0048F9F8.c
@@ -0,0 +1,29 @@
+#include "common.h"
+typedef long long s128;
+
+void func_00473A88(void *object, s32 state, s32 animation);
+
+s32 func_L01_0056B840(s32);
+
+s32 func_L01_0048F9F8(void *arg0, s32 arg1, s32 arg2) {
+    u8 temp_v1;
+    void *temp_v1_2;
+    void *object_owner;
+    s32 nativeObjectValue;
+
+    if ((func_L01_0056B840(arg2) != 0) && ((temp_v1 = (*(u8 *)((s8 *)(arg0) + (0x20))), (temp_v1 == 1)) || (temp_v1 == 4))) {
+        temp_v1_2 = (*(void **)((s8 *)(arg0) + (0xAC)));
+        (*(s128 *)((s8 *)(arg0) + (0x10))) = (s128) (*(s128 *)((s8 *)(temp_v1_2) + (0)));
+        (*(s32 *)((s8 *)(temp_v1_2) + (0x10))) = arg1;
+        (*(s32 *)((s8 *)(temp_v1_2) + (0x14))) = arg2;
+        (*(s8 *)((s8 *)(arg0) + (0x31))) = 1;
+        (*(u16 *)((s8 *)(arg0) + (0x34))) = (u16) ((*(u16 *)((s8 *)(arg0) + (0x34))) & 0xFFFE);
+        object_owner = (*(void **)((s8 *)(arg0) + (0x24)));
+        nativeObjectValue = (*(s32 *)((s8 *)(object_owner) + (0x10)));
+        (*(s8 *)((s8 *)(arg0) + (0x23))) = 0;
+        (*(s32 *)((s8 *)(arg0) + (0x98))) = nativeObjectValue;
+        func_00473A88(arg0, 3, -1);
+        return 1;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L01_00495A60.c b/src/overlays/shared/L01_00495A60.c
new file mode 100644
index 000000000..70f27e6ea
--- /dev/null
+++ b/src/overlays/shared/L01_00495A60.c
@@ -0,0 +1,21 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+extern s64 func_L01_004958F0(void *object);
+
+u32 func_L01_00495A60(void *object)
+{
+    u32 value;
+    u32 result;
+    u8 disabled;
+
+    value = (u32)*(u8 **)((u8 *)object + 0xAC);
+    disabled = ((u8 *)value)[0x458];
+    result = 0;
+    if (disabled == 0) {
+        value = func_L01_004958F0(object) != 0;
+        result = value;
+    }
+    value = result;
+    return value;
+}
diff --git a/src/overlays/shared/L01_0049A7E8.c b/src/overlays/shared/L01_0049A7E8.c
new file mode 100644
index 000000000..25b1d38e6
--- /dev/null
+++ b/src/overlays/shared/L01_0049A7E8.c
@@ -0,0 +1,66 @@
+/* cflags: -O2 -G8 */
+#include "common.h"
+
+typedef struct V_0049A7E8 {
+    u8 pad0[0x18];
+    f32 unk18;
+    f32 unk1C;
+    s32 unk20[3];
+    s32 unk2C;
+} V_0049A7E8;
+
+typedef struct M_0049A7E8 {
+    u8 pad0[0x20];
+    u8 unk20;
+    u8 pad21[0xAC - 0x21];
+    V_0049A7E8 *unkAC;
+} M_0049A7E8;
+
+typedef struct G_0049A7E8 {
+    u8 pad0[0x2E20];
+    f32 unk2E20;
+} G_0049A7E8;
+
+M_0049A7E8 *D_00221CC0 = 0;
+extern s32 D_0021DDB4;
+extern s32 D_0024AD20[];
+extern s16 D_0024AD4C[];
+extern G_0049A7E8 *func_006658C0(s32);
+extern s32 func_L00_005A00F8(void);
+extern s32 func_L00_005BC980(void *);
+extern s32 func_L01_0049A8F0(M_0049A7E8 *);
+extern void func_L01_0049A9C0(M_0049A7E8 *);
+
+void func_L01_0049A7E8(M_0049A7E8 *arg0) {
+    V_0049A7E8 *v;
+    M_0049A7E8 *m;
+    u8 t;
+
+    v = arg0->unkAC;
+    if (func_L01_0049A8F0(arg0) != 0) {
+        return;
+    }
+    m = D_00221CC0;
+    if (m != arg0) {
+        return;
+    }
+    if ((u32)(D_0021DDB4 - 1) < 2) {
+        return;
+    }
+    if (func_L00_005A00F8() != 0) {
+        return;
+    }
+    t = m->unk20;
+    if (t == 1 && func_L00_005BC980(&v->unk20) != 0) {
+        func_L00_005BC980(&v->unk2C);
+        if (D_0024AD20[0] != t && D_0024AD4C[0] <= 0) {
+            if (v->unk2C <= 0) {
+                func_L01_0049A9C0(m);
+            }
+        } else if (v->unk2C < 300) {
+            v->unk2C = 300;
+        }
+    }
+    v->unk18 = func_006658C0(0)->unk2E20;
+    v->unk1C = func_006658C0(1)->unk2E20;
+}
diff --git a/src/overlays/shared/L01_004AC628.c b/src/overlays/shared/L01_004AC628.c
new file mode 100644
index 000000000..76ef1b276
--- /dev/null
+++ b/src/overlays/shared/L01_004AC628.c
@@ -0,0 +1,32 @@
+#include "common.h"
+
+void func_00473A88(void *object, s32 state, s32 animation);
+
+s32 func_L01_005A2F40(void *, void *);
+
+void func_L01_004AC628(void *arg0) {
+    u8 temp_v1;
+    u8 temp_v1_2;
+    void *temp_a1;
+
+    temp_v1 = (*(u8 *)((s8 *)(arg0) + (0x69)));
+    temp_a1 = (*(void **)((s8 *)(arg0) + (0xAC)));
+    switch (temp_v1) {
+    case 0:
+        if (((*(u8 *)((s8 *)(temp_a1) + (0x632))) == 0) && ((*(s32 *)((s8 *)(temp_a1) + (0x418))) >= 0)) {
+            func_00473A88(arg0, 3, 1);
+            return;
+        }
+        if (func_L01_005A2F40(arg0, temp_a1 + 0x310) != 0) {
+            func_00473A88(arg0, 5, 2);
+            return;
+        }
+    case 1:
+        return;
+    case 2:
+        if (((*(s32 *)((s8 *)(temp_a1) + (0x334))) < 0) && (temp_v1_2 = (*(u8 *)((s8 *)(arg0) + (0x20))), ((temp_v1_2 == 5) || (temp_v1_2 == 7)))) {
+            func_00473A88(arg0, 1, 0);
+        }
+        break;
+    }
+}
diff --git a/src/overlays/shared/L01_004ADC38.c b/src/overlays/shared/L01_004ADC38.c
new file mode 100644
index 000000000..1148647fe
--- /dev/null
+++ b/src/overlays/shared/L01_004ADC38.c
@@ -0,0 +1,21 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+extern s64 func_L01_004ADFB0(void *object);
+
+u32 func_L01_004ADC38(void *object)
+{
+    u32 value;
+    u32 result;
+    u8 disabled;
+
+    value = (u32)*(u8 **)((u8 *)object + 0xAC);
+    disabled = ((u8 *)value)[0x408];
+    result = 0;
+    if (disabled == 0) {
+        value = func_L01_004ADFB0(object) != 0;
+        result = value;
+    }
+    value = result;
+    return value;
+}
diff --git a/src/overlays/shared/L01_004AFD28.c b/src/overlays/shared/L01_004AFD28.c
new file mode 100644
index 000000000..12b1b6935
--- /dev/null
+++ b/src/overlays/shared/L01_004AFD28.c
@@ -0,0 +1,19 @@
+#include "common.h"
+
+extern void func_00473A88(void *, s32, s32);
+
+void func_L01_004AFD28(u8 *arg0) {
+    u8 *vars = *(u8 **)(arg0 + 0xAC);
+
+    if (*(s32 *)(vars + 0x10) > 0) {
+        u8 flags;
+        func_00473A88(arg0, 2, -1);
+        flags = arg0[0xBE];
+        if ((flags ^ 1) & 1) {
+            arg0[0xBE] = flags | 1;
+        }
+        *(s16 *)(vars + 0xC) = (f32)*(s32 *)(vars + 0x10) * 60.0f;
+    } else {
+        func_00473A88(arg0, 1, -1);
+    }
+}
diff --git a/src/overlays/shared/L01_004B2DC8.c b/src/overlays/shared/L01_004B2DC8.c
new file mode 100644
index 000000000..66d9faa97
--- /dev/null
+++ b/src/overlays/shared/L01_004B2DC8.c
@@ -0,0 +1,22 @@
+#include "common.h"
+
+void func_00473A88(void *object, s32 state, s32 animation);
+
+s32 func_L01_004B3D48(void *);
+
+void func_L01_004B2DC8(void *arg0) {
+    s32 temp_v1;
+    void *extension;
+
+    extension = *(void **)((u8 *)arg0 + 0xAC);
+    if ((*(u8 *)((s8 *)(arg0) + (0x69))) != 6) {
+        temp_v1 = (*(s32 *)((s8 *)(extension) + (0x3D0)));
+        if (temp_v1 & 4) {
+            if (func_L01_004B3D48(arg0) != 0) {
+                func_00473A88(arg0, 0xC, 6);
+            }
+        } else if ((temp_v1 & 1) && (func_L01_004B3D48(arg0) != 0)) {
+            func_00473A88(arg0, 0xE, 6);
+        }
+    }
+}
diff --git a/src/overlays/shared/L01_004B3FE8.c b/src/overlays/shared/L01_004B3FE8.c
new file mode 100644
index 000000000..2a8275cbb
--- /dev/null
+++ b/src/overlays/shared/L01_004B3FE8.c
@@ -0,0 +1,21 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+extern s64 func_L01_004B3D18(void *object);
+
+u32 func_L01_004B3FE8(void *object)
+{
+    u32 value;
+    u32 result;
+    u8 disabled;
+
+    value = (u32)*(u8 **)((u8 *)object + 0xAC);
+    disabled = ((u8 *)value)[0x458];
+    result = 0;
+    if (disabled == 0) {
+        value = func_L01_004B3D18(object) != 0;
+        result = value;
+    }
+    value = result;
+    return value;
+}
diff --git a/src/overlays/shared/L01_004C1D28.c b/src/overlays/shared/L01_004C1D28.c
new file mode 100644
index 000000000..164b039ab
--- /dev/null
+++ b/src/overlays/shared/L01_004C1D28.c
@@ -0,0 +1,32 @@
+#include "common.h"
+
+extern s32 func_L00_005E0B30(void *, s32, s32, s32, f32, s32, s32);
+extern s32 func_L00_005EE1D8(void *, f32);
+extern void func_L00_005EEA48(void *, s32, s32, s32);
+extern s32 func_L01_004C6600(void *);
+
+s32 func_L01_004C1D28(u8 *moby, s32 arg1) {
+    u8 *vars;
+    s32 v;
+    s32 a;
+
+    vars = *(u8 **)(moby + 0xAC);
+    switch (arg1) {
+    case 1:
+        if (func_L00_005EE1D8(moby, 12.0f) != 0) {
+            a = func_L01_004C6600(moby);
+            *(s32 *)(vars + 0x4C8) = a;
+            func_L00_005EEA48(moby, a, 3, 0);
+            v = *(s16 *)(vars + 0x49E) << 16;
+            *(s32 *)(vars + 0x49C) = v;
+            *(s16 *)(moby + 0x74) = v >> 11;
+            *(s8 *)(vars + 0x4BF) = arg1;
+        }
+        break;
+    case 4:
+        *(s32 *)(vars + 0x4C0) = func_L00_005E0B30(moby, *(s32 *)(*(u8 **)(moby + 0x24) + 0x74), 0xB, 5, 0.0f, 0xB, 0xFF);
+        *(s32 *)(vars + 0x4C4) = func_L00_005E0B30(moby, *(s32 *)(*(u8 **)(moby + 0x24) + 0x74), 0xB, 5, 0.0f, 0xC, 0xFF);
+        break;
+    }
+    return 1;
+}
diff --git a/src/overlays/shared/L01_004C7C58.c b/src/overlays/shared/L01_004C7C58.c
new file mode 100644
index 000000000..7e7286fcf
--- /dev/null
+++ b/src/overlays/shared/L01_004C7C58.c
@@ -0,0 +1,21 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+extern s64 func_L01_004C80A8(void *object);
+
+u32 func_L01_004C7C58(void *object)
+{
+    u32 value;
+    u32 result;
+    u8 disabled;
+
+    value = (u32)*(u8 **)((u8 *)object + 0xAC);
+    disabled = ((u8 *)value)[0x408];
+    result = 0;
+    if (disabled == 0) {
+        value = func_L01_004C80A8(object) != 0;
+        result = value;
+    }
+    value = result;
+    return value;
+}
diff --git a/src/overlays/shared/L01_004C9148.c b/src/overlays/shared/L01_004C9148.c
new file mode 100644
index 000000000..5081b599e
--- /dev/null
+++ b/src/overlays/shared/L01_004C9148.c
@@ -0,0 +1,46 @@
+/* cflags: -G0 */
+#include "common.h"
+
+typedef int u128 __attribute__((mode(TI)));
+
+typedef struct Type1 {
+    u8 pad0[0x22];
+    u8 unk22;
+} Type1;
+
+typedef struct M_004C9148 {
+    u8 pad0[0x10];
+    u128 pos;
+    u8 pad20[0xAC - 0x20];
+    Type1 *unkAC;
+    u8 padB0[0xC0 - 0xB0];
+    u128 mtx[3];
+} M_004C9148;
+
+extern u8 D_003AB250[];
+extern void func_004C8F08(M_004C9148 *, void *, s32, u128 *, s32, s32, s32, s32, s32,
+                          f32, f32, f32, f32, f32, f32, f32);
+
+void func_L01_004C9148(M_004C9148 *arg0) {
+    u128 m[4];
+    u128 *src;
+    u128 *p = m;
+    Type1 *s;
+    s32 max;
+    f32 t;
+
+    src = arg0->mtx;
+    s = arg0->unkAC;
+    max = 40;
+    p[0] = src[2];
+    p[1] = arg0->mtx[0];
+    p[2] = src[1];
+    p[3] = arg0->pos;
+    if (s->unk22 <= max) {
+        t = (f32)s->unk22 / (f32)max;
+    } else {
+        t = 1.0f;
+    }
+    func_004C8F08(arg0, D_003AB250, 3, m, 0x45, 2, 0x597B98, 0x162A3C, 0x10,
+                  0.7f, 2.5f, (f32)s->unk22 / 40.0f, t, 5.0f, 1.25f, 1.75f);
+}
diff --git a/src/overlays/shared/L01_004D8C60.c b/src/overlays/shared/L01_004D8C60.c
new file mode 100644
index 000000000..761de5503
--- /dev/null
+++ b/src/overlays/shared/L01_004D8C60.c
@@ -0,0 +1,24 @@
+#include "common.h"
+
+extern void func_00591BD8(void *, s32, s32);
+
+void func_L01_004D8C60(void *arg0, u8 *arg1) {
+    u8 state = arg1[0x20];
+    u8 *vars = *(u8 **)(arg1 + 0xAC);
+
+    if (state != 0 && state != 4 && state != 6) {
+        s32 v;
+        u8 kind;
+        func_00591BD8(arg1, 1, -1);
+        kind = arg1[0x68];
+        if (kind == 2) {
+            v = (s32)((f32)*(s32 *)(vars + 0x104) * 60.0f) - *(u16 *)(vars + 0x116);
+        } else {
+            if (kind != 5) {
+                return;
+            }
+            v = (s32)((f32)*(s32 *)(vars + 0x104) * 60.0f);
+        }
+        *(s16 *)(vars + 0x114) = v;
+    }
+}
diff --git a/src/overlays/shared/L01_004D9AD8.c b/src/overlays/shared/L01_004D9AD8.c
new file mode 100644
index 000000000..634977516
--- /dev/null
+++ b/src/overlays/shared/L01_004D9AD8.c
@@ -0,0 +1,33 @@
+#include "common.h"
+
+const char *func_0045E038(s32 id);
+void func_00473A88(void *object, s32 state, s32 animation);
+void func_L01_005D74F0(s32 a0, s32 a1, s32 a2);
+
+s32 func_004534D0(void *);
+extern s32 D_0021EBDC;
+
+void func_L01_004D9AD8(void *arg0) {
+    u8 temp_v1;
+    void *temp_s1;
+
+    temp_v1 = (*(u8 *)((s8 *)(arg0) + (0x20)));
+    temp_s1 = (*(void **)((s8 *)(arg0) + (0xAC)));
+    switch (temp_v1) {
+    case 0:
+        (*(s32 *)((s8 *)(temp_s1) + (4))) = (s32) ((f32) (*(s32 *)((s8 *)(temp_s1) + (0))) * 60.0f);
+        func_00473A88(arg0, 1, -1);
+        return;
+    case 1:
+        if (D_0021EBDC != 0) {
+            func_00473A88(arg0, 2, -1);
+            return;
+        }
+        if (func_004534D0(temp_s1 + 4) != 0) {
+            D_0021EBDC = 2;
+            func_00473A88(arg0, 2, -1);
+        }
+        func_L01_005D74F0(0, (s32)func_0045E038(0x255D), (*(s32 *)((s8 *)(temp_s1) + (4))));
+        return;
+    }
+}
diff --git a/src/overlays/shared/L01_004E49D8.c b/src/overlays/shared/L01_004E49D8.c
new file mode 100644
index 000000000..fc2fbb77e
--- /dev/null
+++ b/src/overlays/shared/L01_004E49D8.c
@@ -0,0 +1,33 @@
+/* cflags: -O2 -G8 */
+extern int func_L01_004E4AB8(void *);
+extern int func_L01_004E4B20(void *);
+extern void func_005A85F8(void *, int, int);
+extern int func_L01_004E4E50(void *);
+extern void func_00473A88(void *, int, int);
+extern void func_004E1F90(int, int, void *);
+extern void func_00476F88(void *, int, int, int);
+extern void func_L01_004E4C38(void *);
+
+void func_L01_004E49D8(unsigned char *p)
+{
+    int changed;
+    if (func_L01_004E4AB8(p)) return;
+    if (func_L01_004E4B20(p)) return;
+    switch (p[0x20]) {
+    case 2: {
+        func_005A85F8(p, 17, -1);
+        if (func_L01_004E4E50(p)) func_00473A88(p, 3, -1);
+    break; }
+    case 3: {
+        if ((p[0xbe] ^ 1) & 1) {
+            p[0xbe] |= 1;
+            changed = 1;
+        } else changed = 0;
+        if (changed) {
+            func_004E1F90(0, 0, p);
+            func_00476F88(p, 4, 0, 0);
+        }
+    }
+    }
+    func_L01_004E4C38(p);
+}
diff --git a/src/overlays/shared/L01_004E4B20.c b/src/overlays/shared/L01_004E4B20.c
new file mode 100644
index 000000000..624fbde1c
--- /dev/null
+++ b/src/overlays/shared/L01_004E4B20.c
@@ -0,0 +1,41 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad0[0x3C];
+    u8 *moby;
+} Target;
+
+extern Target D_002423C0[];
+
+extern void func_004771B0(u8 *, u8 *);
+extern s32 func_L01_004E4E50(u8 *);
+extern s32 func_00453508(s16 *);
+extern u8 *func_00474DD0(u8 *, s32, s32);
+extern void func_00476F88(u8 *, s32, s32, s32);
+
+s32 func_L01_004E4B20(u8 *moby) {
+    u8 *vars = *(u8 **)(moby + 0xAC);
+    u8 *hit;
+    s32 dmg;
+
+    func_004771B0(moby, vars + 0xE0);
+    if (func_L01_004E4E50(moby) != 0 || vars[0xF4] == 0) {
+        *(u16 *)(moby + 0x34) &= 0xEFFF;
+        return 0;
+    }
+    *(u16 *)(moby + 0x34) |= 0x1000;
+    func_00453508((s16 *)(vars + 0x7A));
+    if (moby[0x2C] == 0xFF || (&D_002423C0[0] + moby[0x2C])->moby != moby) {
+        hit = NULL;
+    } else {
+        hit = func_00474DD0(moby, 0x1800, 0);
+    }
+    if (hit != NULL && *(s16 *)(vars + 0x7A) == 0) {
+        dmg = *(f32 *)(hit + 0x2C);
+        *(s16 *)(vars + 0x7A) = 0x5;
+        *(f32 *)(vars + 0x50) -= dmg;
+        func_00476F88(moby, 1, 0, 0);
+    }
+    moby[0x2C] = 0xFF;
+    return 0;
+}
diff --git a/src/overlays/shared/L01_004EBC88.c b/src/overlays/shared/L01_004EBC88.c
new file mode 100644
index 000000000..d9c6fab0a
--- /dev/null
+++ b/src/overlays/shared/L01_004EBC88.c
@@ -0,0 +1,28 @@
+#include "common.h"
+s32 func_004E1F90(s32 sound, u32 flags, void *moby);
+void func_L01_004EBC88(void *arg0, void *arg1, s32 arg2) {
+ s32 *entries;
+ s32 *p;
+ s32 value;
+ s32 bit;
+ s32 i;
+ s32 active;
+ s32 occupied;
+ s32 freeIndex;
+ if (arg2 != 0 && *(u8 *)((s8 *)arg1 + 0x2F1) != 0) {
+  entries = (s32 *)((s8 *)arg1 + 0x378);
+  freeIndex = -1; occupied = 0; active = 0; i = 0; p = entries;
+  do {
+   value = *p;
+   if (value == arg2) return;
+   if (value == 0) freeIndex = i;
+   else occupied++;
+   bit = ((s32)*(u8 *)((s8 *)arg1 + 0x2F1) >> i) & 1;
+   p++; i++; active += bit;
+  } while (i < 6);
+  if (freeIndex >= 0 && occupied < active) {
+   func_004E1F90(10, 0, arg0);
+   *(s32 *)((u32)entries + ((u32)freeIndex << 2)) = arg2;
+  }
+ }
+}
diff --git a/src/overlays/shared/L01_004F2F20.c b/src/overlays/shared/L01_004F2F20.c
new file mode 100644
index 000000000..c69bb6732
--- /dev/null
+++ b/src/overlays/shared/L01_004F2F20.c
@@ -0,0 +1,67 @@
+#include "common.h"
+
+extern void func_L00_006BB8E8(s32);
+extern void func_L00_006EF5C0(void *, u32, s32, s32);
+extern s32 func_L01_004F3128(void *, s32, s32);
+
+typedef struct {
+    u8 pad0[0x2B8];
+    s32 f2B8;
+    s32 f2BC;
+    u8 pad2C0[0x2D8 - 0x2C0];
+    s32 f2D8;
+    u8 pad2DC[0x2E8 - 0x2DC];
+    f32 f2E8;
+} Target;
+
+typedef struct {
+    u8 pad0[0x8];
+    Target *(*find)(s32);
+} FinderVt;
+
+typedef struct {
+    u8 pad0[0x40];
+    u8 f40;
+    u8 pad41[0x4C - 0x41];
+    FinderVt *vt;
+} Ctx;
+
+typedef struct {
+    u8 pad0[0xB8];
+    s32 fB8;
+} Self;
+
+void func_L01_004F2F20(Self *self, Ctx *ctx) {
+    Target *t = ctx->vt->find(self->fB8);
+    s32 n;
+    s32 i;
+    s32 flag;
+
+    if (t == NULL || t->f2E8 <= 0.0f) {
+        return;
+    }
+    n = 0;
+    for (i = 0; i < 4; i++) {
+        if (func_L01_004F3128(ctx, i, 0) != 0) {
+            n++;
+        }
+    }
+    if (n < 3) {
+        return;
+    }
+    if (t->f2D8 & 4) {
+        flag = 1;
+    } else {
+        flag = 0;
+    }
+    if (t->f2B8 != 0) {
+        func_L00_006BB8E8(t->f2B8);
+    }
+    if (t->f2BC != 0) {
+        func_L00_006BB8E8(t->f2BC);
+    }
+    ctx->f40 = 1;
+    if (flag) {
+        func_L00_006EF5C0(t, 0xFFFFFFFF, 0xD, -1);
+    }
+}
diff --git a/src/overlays/shared/L01_00500548.c b/src/overlays/shared/L01_00500548.c
new file mode 100644
index 000000000..8137f5ea8
--- /dev/null
+++ b/src/overlays/shared/L01_00500548.c
@@ -0,0 +1,89 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad0[0x30];
+    void (*func30)(void *, s32);
+} Ops;
+
+typedef struct {
+    u8 pad0[0x1A];
+    s16 unk1A;
+    s16 unk1C;
+    u8 pad1E[0x3E - 0x1E];
+    u8 unk3E;
+    u8 pad3F;
+    s32 unk40;
+    f32 unk44;
+    f32 unk48;
+    f32 unk4C;
+} Cfg;
+
+typedef struct {
+    u8 pad0[0xC];
+    u8 *unkC;
+    u8 pad10[0x2C - 0x10];
+    u8 *unk2C;
+    u8 pad30[0x7C - 0x30];
+    s16 unk7C;
+} Sub;
+
+extern u8 *func_00476690(void *);
+extern void *func_0047BBD8(void *);
+extern u8 *func_0053CC88(void *);
+extern void func_L01_005A37B8(void *, s32, s32, s32, s32);
+
+void func_L01_00500548(u8 *arg0) {
+    u8 *vars = *(u8 **)(arg0 + 0xAC);
+    u8 *info;
+    u8 *other_info;
+    Cfg *cfg;
+    s32 n;
+    u8 *extra;
+    u8 *obj;
+
+    info = func_00476690(*(void **)(vars + 0x1D8));
+    obj = *(u8 **)(vars + 0x1D8);
+    if (*(s16 *)(obj + 0xBC) == 0x2722) {
+        Sub *p = *(Sub **)(obj + 0xAC);
+        p->unkC = (u8 *)p + 0xE0;
+        p->unk2C = (u8 *)p + 0x170;
+        p->unk7C = 8;
+    }
+    other_info = func_0047BBD8(*(void **)(vars + 0x1D8));
+    (*(Ops **)(vars + 0x204))->func30(*(void **)(vars + 0x1D8), 0);
+    cfg = func_0047BBD8(*(void **)(vars + 0x1D8));
+    cfg->unk40 = 1;
+    cfg->unk1C = 3;
+    cfg->unk48 = 30.0f;
+    cfg->unk1A = 7;
+    cfg->unk3E = 20;
+    cfg->unk44 = 1.0f;
+    cfg->unk4C = 15.0f;
+    if (*(s32 *)(vars + 0x1C4) == -1 && *(s32 *)(vars + 0x1C8) == -1 &&
+        *(s32 *)(other_info + 0x30) != -1) {
+        *(s32 *)(vars + 0x1C4) = *(s32 *)(other_info + 0x30);
+        *(s32 *)(vars + 0x1C8) = *(s32 *)(other_info + 0x30);
+    } else if (*(s32 *)(vars + 0x1C4) == -1) {
+        if (*(s32 *)(vars + 0x1C8) != *(s32 *)(vars + 0x1C4)) {
+            *(s32 *)(vars + 0x1C4) = *(s32 *)(vars + 0x1C8);
+        }
+    } else if (*(s32 *)(vars + 0x1C8) == -1) {
+        *(s32 *)(vars + 0x1C8) = *(s32 *)(vars + 0x1C4);
+    }
+    func_L01_005A37B8(*(void **)(vars + 0x1D8), 4, 1, 1, 0);
+    extra = func_0053CC88(*(void **)(vars + 0x1D8));
+    if (*(s32 *)(vars + 0x54) < 2) {
+        *(s32 *)(vars + 0x54) = 100;
+    }
+    n = *(s32 *)(vars + 0x54);
+    *(s32 *)(info + 4) = n;
+    *(f32 *)(info + 0) = n;
+    if (extra != NULL) {
+        *(f32 *)(extra + 0x2E8) = *(f32 *)(info + 0);
+        *(f32 *)(extra + 0x2EC) = *(s32 *)(info + 4);
+    }
+    info[8] = vars[0x58];
+    info[9] = vars[0x59];
+    info[10] = vars[0x5A];
+    *(s32 *)(vars + 0x1EC) = *(s16 *)(vars + 0x1FA) * 60.0f;
+}
diff --git a/src/overlays/shared/L01_005008D8.c b/src/overlays/shared/L01_005008D8.c
new file mode 100644
index 000000000..ac87b0703
--- /dev/null
+++ b/src/overlays/shared/L01_005008D8.c
@@ -0,0 +1,81 @@
+#include "common.h"
+
+typedef int u128 __attribute__((mode(TI)));
+
+typedef struct {
+    u8 pad0[0x1C];
+    f32 (*getA)(s32);
+    u8 pad20[0x18];
+    f32 (*getB)(s32);
+} Ops;
+
+extern s16 func_00472590(s32, s32);
+extern void func_L01_00591C70(u8 *, s32);
+extern void func_L01_00501078(u128 *, u8 *);
+extern f32 func_00453B10(f32, f32);
+extern f32 func_00453BF8(f32, f32);
+extern s32 func_00453508(s16 *);
+extern void func_L01_00500888(u8 *);
+
+void func_L01_005008D8(u8 *moby) {
+    u8 *vars = *(u8 **)(moby + 0xAC);
+    u128 v;
+    s32 first;
+    u8 f;
+    f32 a;
+    f32 b;
+
+    f = moby[0xBE];
+    if ((f ^ 1) & 1) {
+        moby[0xBE] = f | 1;
+        first = 1;
+    } else {
+        first = 0;
+    }
+    if (first) {
+        *(s32 *)(vars + 0x174) = 0;
+        *(s16 *)(vars + 0x1F6) = func_00472590(2, 4);
+        func_L01_00591C70(moby, 0);
+    }
+    switch (moby[0x67]) {
+    case 0:
+        f = moby[0xBE];
+        if (!(f & 0x20)) {
+            moby[0xBE] = f | 0x20;
+            first = 1;
+        } else {
+            first = 0;
+        }
+        if (first) {
+            func_L01_00501078(&v, moby);
+            *(u128 *)(vars + 0x190) = v;
+        }
+        a = (*(Ops **)(vars + 0x204))->getA(*(s32 *)(vars + 0x1D8));
+        if (func_00453BF8(a, func_00453B10(*(f32 *)(vars + 0x178), *(f32 *)(vars + 0x198))) < 0.034906585f) {
+            b = (*(Ops **)(vars + 0x204))->getB(*(s32 *)(vars + 0x1D8));
+            if (func_00453BF8(b, func_00453B10(*(f32 *)(vars + 0x174), *(f32 *)(vars + 0x194))) < 0.034906585f) {
+                func_L01_00591C70(moby, 1);
+            }
+        }
+        break;
+    case 1:
+        f = moby[0xBE];
+        if (!(f & 0x20)) {
+            moby[0xBE] = f | 0x20;
+            first = 1;
+        } else {
+            first = 0;
+        }
+        if (first) {
+            *(s16 *)(vars + 0x1F4) = func_00472590(0x14, 0x5A);
+        }
+        if (func_00453508((s16 *)(vars + 0x1F4)) != 0) {
+            if (func_00453508((s16 *)(vars + 0x1F6)) != 0) {
+                func_L01_00500888(moby);
+            } else {
+                func_L01_00591C70(moby, 0);
+            }
+        }
+        break;
+    }
+}
diff --git a/src/overlays/shared/L01_00501688.c b/src/overlays/shared/L01_00501688.c
new file mode 100644
index 000000000..5facb7abc
--- /dev/null
+++ b/src/overlays/shared/L01_00501688.c
@@ -0,0 +1,58 @@
+#include "common.h"
+
+typedef int Vec128 __attribute__((mode(TI)));
+
+typedef struct Obj Obj;
+typedef struct ObjVt {
+    u8 pad0[0x3C];
+    Vec128 (*f3C)(s32);
+} ObjVt;
+typedef struct Vars {
+    u8 pad0[0x1D8];
+    s32 f1D8;
+    u8 pad1DC[0x204 - 0x1DC];
+    ObjVt *f204;
+} Vars;
+typedef struct Info {
+    u8 pad0[0x10];
+    s32 f10;
+} Info;
+typedef struct Type0 {
+    u8 pad0[0x18];
+    s32 f18;
+    s32 f1C;
+} Type0;
+
+extern s32 func_00596F28(s32);
+extern Info *func_005A16E8(s32);
+extern s32 func_L00_005A38F8(Vec128 *, u8 *, s32, s32, s32);
+extern void func_L00_005F1778(s32, u8 *, s32);
+extern Type0 D_00242340;
+extern u8 *D_003660F8[10];
+
+s32 func_L01_00501688(u8 *moby) {
+    u8 buf[16];
+    Vec128 v;
+    Vars *vars;
+    Info *info;
+    u8 *p;
+    s32 i;
+    s32 found;
+
+    found = 0;
+    vars = *(Vars **)(moby + 0xAC);
+    info = func_005A16E8(vars->f1D8);
+    func_L00_005F1778(info->f10, buf, 0);
+    v = vars->f204->f3C(vars->f1D8);
+    for (i = 0, p = D_003660F8[0]; i < 10; p = D_003660F8[++i]) {
+        if (p != NULL && *(s32 *)(p + 0x2EF0) == info->f10 && *(u8 **)(p + 0x2EF4) != NULL) {
+            found = *(s32 *)(*(u8 **)(p + 0x2EF4) + 0x2B0);
+        }
+    }
+    if (func_L00_005A38F8(&v, buf, 2, vars->f1D8, 0) == 0 || D_00242340.f1C == 0 ||
+        (D_00242340.f18 != 0 &&
+         (func_00596F28(D_00242340.f18) != 0 || (found != 0 && D_00242340.f18 == found)))) {
+        return 1;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L01_00501B38.c b/src/overlays/shared/L01_00501B38.c
new file mode 100644
index 000000000..4b6708d1a
--- /dev/null
+++ b/src/overlays/shared/L01_00501B38.c
@@ -0,0 +1,36 @@
+#include "common.h"
+
+typedef unsigned int Quadword __attribute__((mode(TI)));
+typedef union {
+    f32 f[4];
+    Quadword q;
+} Vector;
+extern f32 func_00453B10(f32 angle, f32 delta);
+
+Vector *func_L01_00501B38(Vector *output, const u8 *object, f32 *factor)
+{
+    u8 *state = *(u8 **)(object + 0xAC);
+
+    if (object[0x69] == 2 && object[0x20] == 5) {
+        Vector result;
+        f32 first;
+        f32 second;
+
+        if (factor)
+            *factor = 0.5f;
+        first = func_00453B10(*(f32 *)(state + 0x174), *(f32 *)(state + 0x194));
+        second = func_00453B10(*(f32 *)(state + 0x178), *(f32 *)(state + 0x198));
+        result.f[1] = first;
+        result.f[2] = second;
+        result.f[0] = 0.0f;
+        result.f[3] = 0.0f;
+        output->q = result.q;
+    } else if (object[0x69] == 3 && object[0x20] == 6) {
+        if (factor)
+            *factor = 0.5f;
+        output->q = *(Quadword *)(state + 0x170);
+    } else {
+        output->q = *(Quadword *)(state + 0x170);
+    }
+    return output;
+}
diff --git a/src/overlays/shared/L01_00501C18.c b/src/overlays/shared/L01_00501C18.c
new file mode 100644
index 000000000..f2c859db1
--- /dev/null
+++ b/src/overlays/shared/L01_00501C18.c
@@ -0,0 +1,26 @@
+#include "common.h"
+
+f32 *func_00595DA0(s32);
+s32 func_L01_00501C18(void *arg0)
+{
+  s32 temp_a1;
+  s32 var_a0;
+  s32 var_v0;
+  u8 temp_v1;
+  var_v0 = 0;
+  if (!((*func_00595DA0(*((s32 *) (((s8 *) (*((void **) (((s8 *) arg0) + 0xAC)))) + 0x1D8)))) <= 0.0f))
+  {
+    var_a0 = 0;
+    if ((*((u8 *) (((s8 *) arg0) + 0x69))) == 3)
+    {
+      temp_v1 = *((u8 *) (((s8 *) arg0) + 0x20));
+      if ((temp_v1 ^ 6) != 0)
+        temp_a1 = 0;
+      else
+        temp_a1 = 0x28;
+      var_a0 = ((temp_v1 ^ 8) == 0) ? (temp_a1 | 0x84) : (temp_a1);
+    }
+    return var_a0;
+  }
+  return var_v0;
+}
diff --git a/src/overlays/shared/L01_0051D538.c b/src/overlays/shared/L01_0051D538.c
new file mode 100644
index 000000000..113070f15
--- /dev/null
+++ b/src/overlays/shared/L01_0051D538.c
@@ -0,0 +1,28 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad[80];
+    u8 *p50;
+    u8 pad2[1036];
+} Entry_3E6C58;
+extern u8 D_00231810[];
+extern Entry_3E6C58 D_00230280[];
+
+void func_L01_0051D538(s32 idx, s32 flag, f32 a, f32 b)
+{
+    u8 *e = (u8 *)D_00230280 + idx * 0x470;
+    u8 *p = *(u8 **)(e + 0x50);
+    if (*(s16 *)(p + 134) == 0) {
+        u8 *q = *(u8 **)(p + 112);
+        u8 *r = q + 0x60;
+        *(s16 *)(r + 0xFA) = 1;
+        *(f32 *)(r + 0xD8) = b;
+        if (flag) {
+            u8 *f = (u8 *)D_00231810 + idx * 0xB0;
+            u8 *s = *(u8 **)(f + 0x70);
+            *(f32 *)(r + 0xD4) = *(f32 *)(s + 0x130) + a;
+        } else {
+            *(f32 *)(r + 0xD4) = a;
+        }
+    }
+}
diff --git a/src/overlays/shared/L01_0051D7F0.c b/src/overlays/shared/L01_0051D7F0.c
new file mode 100644
index 000000000..bd322c72b
--- /dev/null
+++ b/src/overlays/shared/L01_0051D7F0.c
@@ -0,0 +1,21 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad[80];
+    u8 *p50;
+    u8 pad2[1036];
+} Entry_3E6C58;
+extern Entry_3E6C58 D_00230280[];
+
+void func_L01_0051D7F0(s32 player, s32 axes) {
+    u8 *e = ((u8 *)&D_00230280) + player * 1136;
+    u8 *o = *(u8 **)(e + 80);
+    if (*(s16 *)(o + 134) == 0) {
+        u8 *p = *(u8 **)(o + 112) + 0x1E0;
+        if (axes == -1) {
+            *(u32 *)(p + 0x10) |= 3;
+        } else {
+            *(u32 *)(p + 0x10) |= axes;
+        }
+    }
+}
diff --git a/src/overlays/shared/L01_005334B0.c b/src/overlays/shared/L01_005334B0.c
new file mode 100644
index 000000000..f290a5356
--- /dev/null
+++ b/src/overlays/shared/L01_005334B0.c
@@ -0,0 +1,68 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad0[0x70];
+    s32 x70;
+    s32 x74;
+    u8 pad78[0xC];
+    s16 n;
+    u8 pad86[0x16A];
+    u8 *mobys[1];
+} Arena;
+
+extern Arena D_0023F600;
+extern u8 *D_003660F8[];
+extern s32 D_0021DE10;
+extern void func_L00_00596A28(s32, s32, s32, s32);
+extern void func_L00_00598118(s32);
+extern void func_L01_0052CE98(void);
+
+void func_L01_005334B0(void) {
+    u8 *moby;
+    u8 *m;
+    u8 *q;
+    s32 i;
+    s32 j;
+    s32 id;
+
+    for (i = 0; i < D_0023F600.n; i++) {
+        moby = D_0023F600.mobys[i];
+        if (moby != NULL) {
+            id = *(s16 *)(moby + 0xBC);
+            if (id == 0x216A || id == 0x2691 || (id == 0x2429 && D_0021DE10 == 0x2574) || id == 0x20FD || id == 0x2703 || id == 0x2505) {
+                func_L00_00596A28(i, 0x96, 0, 0);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x216A || *(s16 *)(moby + 0xBC) == 0x2691) {
+                *(u16 *)(D_0023F600.mobys[i] + 0x74) |= 0x1000;
+            }
+            if (*(s16 *)(moby + 0xBC) == 0xA) {
+                m = D_0023F600.mobys[i];
+                if (D_0023F600.x70 == 2) {
+                    *(u16 *)(m + 0x74) |= 0x1000;
+                } else {
+                    *(u16 *)(m + 0x74) |= 0x1002;
+                }
+                func_L00_00596A28(i, 0x6E, 0x80306629, 0x8058B856);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x243D) {
+                func_L00_00596A28(i, 0x168, 0xC0808080, 0x80505050);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x247F || *(s16 *)(moby + 0xBC) == 0x24D9 || *(s16 *)(moby + 0xBC) == 0x24D5) {
+                func_L00_00596A28(i, 0x5A, 0xFFC0C0C0, 0xB0505050);
+            }
+        }
+    }
+    func_L01_0052CE98();
+    if (D_0023F600.x70 == 0x14 && D_0023F600.x74 < 0xA0) {
+        func_L00_00598118(0);
+    }
+    if (D_0023F600.x70 == 0x15 && D_0023F600.x74 >= 0x65) {
+        func_L00_00598118(0);
+    }
+    func_L00_00598118(0);
+    for (j = 0, q = D_003660F8[0]; j < 10; q = D_003660F8[++j]) {
+        if (q != NULL) {
+            (*(u8 **)(q + 0x2EF0))[0x31] = 0;
+        }
+    }
+}
diff --git a/src/overlays/shared/L01_0055CBE0.c b/src/overlays/shared/L01_0055CBE0.c
new file mode 100644
index 000000000..7803bfaa5
--- /dev/null
+++ b/src/overlays/shared/L01_0055CBE0.c
@@ -0,0 +1,8 @@
+/* cflags: -Wuninitialized */
+#include "common.h"
+extern void func_0044DE80(u64, s64, s64, u64);
+extern s32 D_00222B10;
+void func_L01_0055CBE0(void)
+{
+    func_0044DE80((u64)&D_00222B10, 0x47, 0x513F1, 0U);
+}
diff --git a/src/overlays/shared/L01_0056D0C8.c b/src/overlays/shared/L01_0056D0C8.c
new file mode 100644
index 000000000..cd583a83e
--- /dev/null
+++ b/src/overlays/shared/L01_0056D0C8.c
@@ -0,0 +1,56 @@
+#include "common.h"
+
+extern s32 func_0056D480(void *, void *);
+extern void func_0056E630(void *, s32);
+extern s32 func_0056B748(void *);
+extern s32 func_0056D560(void *);
+extern s32 func_00569478(void *, void *);
+extern s32 func_0055D148(void *);
+extern void func_0056C878(void *, void *);
+extern s32 func_0056B640(void *, s32);
+extern u8 *D_00222D14;
+
+void func_L01_0056D0C8(u8 *arg0) {
+    u8 *n;
+    s32 idle = 1;
+
+    if (arg0 == NULL) {
+        return;
+    }
+    for (n = *(u8 **)(arg0 + 0x3F0); n != NULL; n = *(u8 **)(n + 0x1AC)) {
+        if (n[0x1DA] == 0 && *(s32 *)(n + 0x1C8) != -1 && func_0056D480(arg0, n) != 0) {
+            func_0056E630(D_00222D14 + (*(s32 *)(n + 0x1C8) << 8), -1);
+            n[0x1DA] = 1;
+        }
+        if (func_0056B748(n) != 0) {
+            continue;
+        }
+        idle = 0;
+        if (func_0056D560(n) == 0) {
+            continue;
+        }
+        if (n[0x17C] == 0 && func_00569478(n, arg0 + 0xD0) == 0) {
+            continue;
+        }
+        if (func_0055D148(n + 0x19C) != 0) {
+            func_0056C878(arg0, n);
+        }
+    }
+    if (arg0[0] != 0 && idle != 0) {
+        for (n = *(u8 **)(arg0 + 0x3F0); n != NULL; n = *(u8 **)(n + 0x1AC)) {
+            s32 i;
+            u8 *slot;
+            *(s32 *)(n + 0x178) = 0;
+            for (i = 0, slot = n + 0x53; i < 8; i++, slot += 0x24) {
+                if (func_0056B640(n, i) != 0 && *(s32 *)(slot + 1) != -1) {
+                    *(s32 *)(n + 0x178) |= 1 << slot[0];
+                }
+            }
+            n[0x17C] = 0;
+            *(s16 *)(n + 0x1A2) = 0;
+            *(s16 *)(n + 0x17E) = 0;
+            n[0x1DB] = 0;
+            *(s32 *)(n + 0x19C) = *(f32 *)(n + 0x198) * 60.0f;
+        }
+    }
+}
diff --git a/src/overlays/shared/L01_0056F250.c b/src/overlays/shared/L01_0056F250.c
new file mode 100644
index 000000000..6d7baca2f
--- /dev/null
+++ b/src/overlays/shared/L01_0056F250.c
@@ -0,0 +1,14 @@
+#include "common.h"
+typedef long long s128;
+extern s32 func_0056EE18(s128, void *, s128, s128 *, s128 *, void *);
+
+s32 func_L01_0056F250(void *first, void *context, void *second, s128 *output, void *settings)
+{
+    s128 local;
+    if (!first || !second)
+        return 0;
+    local = *(s128 *)((u8 *)second + 0xF0);
+    return func_0056EE18(*(s128 *)((u8 *)first + 0x10), context,
+                           *(s128 *)((u8 *)second + 0x10), &local,
+                           output, settings);
+}
diff --git a/src/overlays/shared/L01_00585D40.c b/src/overlays/shared/L01_00585D40.c
new file mode 100644
index 000000000..9d8c998c0
--- /dev/null
+++ b/src/overlays/shared/L01_00585D40.c
@@ -0,0 +1,11 @@
+#include "common.h"
+
+s32 func_L01_00585B78(void *arg0);
+
+s32 func_L01_00585D40(void *arg0) {
+    if ((*(u8 *)((s8 *)(func_L01_00585B78(arg0)) + (0x10))) != 0) {
+        (*(u16 *)((s8 *)(arg0) + (0x34))) = (u16) ((*(u16 *)((s8 *)(arg0) + (0x34))) | 2);
+        return 1;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L01_00585DB0.c b/src/overlays/shared/L01_00585DB0.c
new file mode 100644
index 000000000..f398531c0
--- /dev/null
+++ b/src/overlays/shared/L01_00585DB0.c
@@ -0,0 +1,15 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+
+extern u8 D_00269EC0[];
+
+void func_L01_00585DB0(void)
+{
+    u8 *record = D_00269EC0;
+
+    do {
+        *(s32 *)(record + 0x104) = 0;
+        *(s32 *)(record + 0x100) = 0;
+        record += 0x110;
+    } while ((s32)record < (s32)(D_00269EC0 + 0x220));
+}
diff --git a/src/overlays/shared/L01_005A37B8.c b/src/overlays/shared/L01_005A37B8.c
new file mode 100644
index 000000000..e34b0f937
--- /dev/null
+++ b/src/overlays/shared/L01_005A37B8.c
@@ -0,0 +1,16 @@
+#include "common.h"
+extern u8 *func_005A3780(const u8 *);
+extern void *func_00476F50(void *);
+extern s32 func_L01_005A4680(void *);
+extern s32 func_L01_005A4648(const u8 *);
+void func_L01_005A37B8(void *object,s32 mode,s32 enable)
+{
+    u8 *state=func_005A3780(object);
+    void *value=func_00476F50(object);
+    if(state){
+        *(s16 *)(state+8)=mode;
+        *(void **)state=value;
+        if(enable)func_L01_005A4680(object);
+        else func_L01_005A4648(object);
+    }
+}
diff --git a/src/overlays/shared/L01_005B4EB0.c b/src/overlays/shared/L01_005B4EB0.c
new file mode 100644
index 000000000..60b6f694b
--- /dev/null
+++ b/src/overlays/shared/L01_005B4EB0.c
@@ -0,0 +1,12 @@
+#include "common.h"
+
+extern void *func_004765F0(void *);
+
+s32 func_L01_005B4EB0(void *arg0, s32 arg1)
+{
+    u8 *state = func_004765F0(arg0);
+    if (!state)
+        return 0;
+    *(s32 *)(state + 0x58) = arg1;
+    return 1;
+}
diff --git a/src/overlays/shared/L01_0063B1B8.c b/src/overlays/shared/L01_0063B1B8.c
new file mode 100644
index 000000000..866e7582c
--- /dev/null
+++ b/src/overlays/shared/L01_0063B1B8.c
@@ -0,0 +1,20 @@
+#include "common.h"
+
+extern int func_0011A930(int, void (*)(void), int);
+typedef unsigned int Rac2Native_74a5d71aacb394c6_u32;
+typedef struct {
+    Rac2Native_74a5d71aacb394c6_u32 first[64];
+    Rac2Native_74a5d71aacb394c6_u32 second[64];
+    unsigned char gap[0x20];
+    int count;
+    Rac2Native_74a5d71aacb394c6_u32 current;
+} Rac2Native_74a5d71aacb394c6_ExtraIndexState48;
+extern int func_0011A930(int, void (*)(void), int);
+
+void func_L01_0063B1B8(Rac2Native_74a5d71aacb394c6_ExtraIndexState48 *state, int index) {
+    state->first[index] = 0;
+    state->second[index] = 0;
+    if (--state->count == 0) {
+        state->current = 0;
+    }
+}
diff --git a/src/overlays/shared/L02_004CB2E8.c b/src/overlays/shared/L02_004CB2E8.c
new file mode 100644
index 000000000..a300bd274
--- /dev/null
+++ b/src/overlays/shared/L02_004CB2E8.c
@@ -0,0 +1,17 @@
+#include "common.h"
+
+extern void func_004C4D88(void *, void *);
+extern void func_00638BF8(s32, s32, s32, s32, f32);
+extern void func_005D7540(s32, s32, void *);
+extern void func_00544188(void *, s32, s32);
+
+void func_L02_004CB2E8(u8 *arg0) {
+    u8 *vars = *(u8 **)(arg0 + 0xAC);
+    s32 target = *(s32 *)(*(u8 **)(vars + 0x170) + 0x2B8);
+
+    func_004C4D88(arg0, vars);
+    func_00638BF8(target, 0x24, 0, 0, 10.0f);
+    *(f32 *)(vars + 0x1F8) = 1.0f;
+    func_005D7540(2, 0, arg0);
+    func_00544188(arg0, 4, -1);
+}
diff --git a/src/overlays/shared/L02_004E6370.c b/src/overlays/shared/L02_004E6370.c
new file mode 100644
index 000000000..d848d326a
--- /dev/null
+++ b/src/overlays/shared/L02_004E6370.c
@@ -0,0 +1,68 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad0[0x70];
+    s32 x70;
+    s32 x74;
+    u8 pad78[0xC];
+    s16 n;
+    u8 pad86[0x16A];
+    u8 *mobys[1];
+} Arena;
+
+extern Arena D_0023C180;
+extern u8 *D_00362C78[];
+extern s32 D_0021DE10;
+extern void func_L00_00596A28(s32, s32, s32, s32);
+extern void func_L00_00598118(s32);
+extern void func_L02_004E3270(void);
+
+void func_L02_004E6370(void) {
+    u8 *moby;
+    u8 *m;
+    u8 *q;
+    s32 i;
+    s32 j;
+    s32 id;
+
+    for (i = 0; i < D_0023C180.n; i++) {
+        moby = D_0023C180.mobys[i];
+        if (moby != NULL) {
+            id = *(s16 *)(moby + 0xBC);
+            if (id == 0x216A || id == 0x2691 || (id == 0x2429 && D_0021DE10 == 0x2574) || id == 0x20FD || id == 0x2703 || id == 0x2505) {
+                func_L00_00596A28(i, 0x96, 0, 0);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x216A || *(s16 *)(moby + 0xBC) == 0x2691) {
+                *(u16 *)(D_0023C180.mobys[i] + 0x74) |= 0x1000;
+            }
+            if (*(s16 *)(moby + 0xBC) == 0xA) {
+                m = D_0023C180.mobys[i];
+                if (D_0023C180.x70 == 2) {
+                    *(u16 *)(m + 0x74) |= 0x1000;
+                } else {
+                    *(u16 *)(m + 0x74) |= 0x1002;
+                }
+                func_L00_00596A28(i, 0x6E, 0x80306629, 0x8058B856);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x243D) {
+                func_L00_00596A28(i, 0x168, 0xC0808080, 0x80505050);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x247F || *(s16 *)(moby + 0xBC) == 0x24D9 || *(s16 *)(moby + 0xBC) == 0x24D5) {
+                func_L00_00596A28(i, 0x5A, 0xFFC0C0C0, 0xB0505050);
+            }
+        }
+    }
+    func_L02_004E3270();
+    if (D_0023C180.x70 == 0x1 && D_0023C180.x74 < 0xA0) {
+        func_L00_00598118(0);
+    }
+    if (D_0023C180.x70 == 0x2 && D_0023C180.x74 >= 0x65) {
+        func_L00_00598118(0);
+    }
+    func_L00_00598118(0);
+    for (j = 0, q = D_00362C78[0]; j < 10; q = D_00362C78[++j]) {
+        if (q != NULL) {
+            (*(u8 **)(q + 0x2EF0))[0x31] = 0;
+        }
+    }
+}
diff --git a/src/overlays/shared/L04_00497910.c b/src/overlays/shared/L04_00497910.c
new file mode 100644
index 000000000..fb6d43274
--- /dev/null
+++ b/src/overlays/shared/L04_00497910.c
@@ -0,0 +1,20 @@
+/* cflags:  -malign-jumps=3 */
+#include "common.h"
+
+void func_004E1A58(int, int);
+void func_L04_00497910(void *arg0, s32 arg1) {
+    u16 temp_3;
+    void *temp_4;
+
+    if (arg1 != 0) {
+        temp_4 = (*(void **)((u8 *)(arg0) + (0x24)));
+        temp_3 = (*(u16 *)((u8 *)(arg0) + (0x34))) & 0xFFBE;
+        (*(u16 *)((u8 *)(arg0) + (0x34))) = temp_3;
+        (*(u16 *)((u8 *)(arg0) + (0x34))) = (u16) (temp_3 | ((*(u16 *)((u8 *)(temp_4) + (0x44))) & 0x1000));
+        (*(s32 *)((u8 *)(arg0) + (0x98))) = (s32) (*(s32 *)((u8 *)(temp_4) + (0x10)));
+        return;
+    }
+    (*(s32 *)((u8 *)(arg0) + (0x98))) = 0;
+    (*(u16 *)((u8 *)(arg0) + (0x34))) = (u16) (((*(u16 *)((u8 *)(arg0) + (0x34))) | 0x41) & 0xEFFF);
+    func_004E1A58((s32) arg0, 1);
+}
diff --git a/src/overlays/shared/L05_004DF580.c b/src/overlays/shared/L05_004DF580.c
new file mode 100644
index 000000000..a2cb86428
--- /dev/null
+++ b/src/overlays/shared/L05_004DF580.c
@@ -0,0 +1,18 @@
+#include "common.h"
+
+void func_00473A88(void *object, s32 state, s32 animation);
+
+s32 func_L05_004DF580(void *arg0, s32 arg1) {
+    s32 temp_v0;
+    void *temp_v1;
+
+    temp_v1 = (*(void **)((s8 *)(arg0) + (0xAC)));
+    if (((*(s32 *)((s8 *)(temp_v1) + (0x140))) == 0) && ((temp_v0 = (*(s32 *)((s8 *)(temp_v1) + (0x144))), (temp_v0 == 0)) || (temp_v0 == arg1))) {
+        (*(s32 *)((s8 *)(temp_v1) + (0x144))) = arg1;
+        if ((*(u8 *)((s8 *)(arg0) + (0x20))) != 6) {
+            func_00473A88(arg0, 3, -1);
+        }
+        return 1;
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L05_004EEEC8.c b/src/overlays/shared/L05_004EEEC8.c
new file mode 100644
index 000000000..d1eaa2fc4
--- /dev/null
+++ b/src/overlays/shared/L05_004EEEC8.c
@@ -0,0 +1,41 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad0[0x3C];
+    u8 *moby;
+} Target;
+
+extern Target D_0023F300[];
+
+extern void func_0056D8F8(u8 *, u8 *);
+extern s32 func_005340D0(s16 *);
+extern u8 *func_0056AF78(u8 *, s32, s32);
+extern void func_0056D6D0(u8 *, s32, s32, s32);
+extern void func_005FD288(s32, s32, u8 *);
+extern void func_00568B98(u8 *, s32, s32);
+
+s32 func_L05_004EEEC8(u8 *moby) {
+    u8 *vars = *(u8 **)(moby + 0xAC);
+    u8 *hit;
+    s32 dmg;
+
+    func_0056D8F8(moby, vars + 0xE0);
+    func_005340D0((s16 *)(vars + 0x7A));
+    if (moby[0x2C] == 0xFF || (&D_0023F300[0] + moby[0x2C])->moby != moby) {
+        hit = NULL;
+    } else {
+        hit = func_0056AF78(moby, 0x1800, 0);
+    }
+    if (hit != NULL && *(s16 *)(vars + 0x7A) == 0) {
+        dmg = *(f32 *)(hit + 0x2C);
+        *(s16 *)(vars + 0x7A) = 0xA;
+        *(f32 *)(vars + 0x50) -= dmg;
+        func_0056D6D0(moby, 1, 0, 0);
+        func_005FD288(1, 0, moby);
+    }
+    moby[0x2C] = 0xFF;
+    if (*(f32 *)(vars + 0x50) <= 0.0f) {
+        func_00568B98(moby, 5, -1);
+    }
+    return 0;
+}
diff --git a/src/overlays/shared/L06_00416C20.c b/src/overlays/shared/L06_00416C20.c
new file mode 100644
index 000000000..376084193
--- /dev/null
+++ b/src/overlays/shared/L06_00416C20.c
@@ -0,0 +1,48 @@
+#include "common.h"
+
+extern void func_L00_005DD4A0(void *);
+extern s32 func_L00_005E60D0(s32, s32);
+extern void func_L00_005E75B0(void *, s32, s32, f32);
+extern s32 func_L00_005E8F08(void *, s32, s32);
+extern s32 func_L00_0066D220(s32, s32, void *);
+extern void func_L01_00591BD8(void *, s32, s32);
+extern void func_L01_005A0A30(void *, s32, s32);
+
+typedef struct {
+    u8 pad0[0x3C];
+    void *owner;
+} Slot;
+
+extern Slot D_0023EDC0[];
+
+typedef struct {
+    u8 pad0[0x20];
+    u8 state;
+    u8 pad21[0x2C - 0x21];
+    u8 slot;
+} Obj;
+
+void func_L06_00416C20(Obj *o) {
+    s32 ok;
+    f32 f;
+
+    switch (o->state) {
+    case 0:
+        f = func_L00_005E60D0(0, 0x13);
+        func_L00_005E75B0(o, 2, func_L00_005E60D0(0, 0x13), f);
+        func_L01_00591BD8(o, 1, -1);
+        break;
+    case 1:
+        if (o->slot == 0xFF || (D_0023EDC0 + o->slot)->owner != o) {
+            ok = 0;
+        } else {
+            ok = func_L00_005E8F08(o, 0x0FFFFFFF, 0);
+        }
+        if (ok) {
+            func_L00_0066D220(0, 0, o);
+            func_L01_005A0A30(o, 0x26CC, 0);
+            func_L00_005DD4A0(o);
+        }
+        break;
+    }
+}
diff --git a/src/overlays/shared/L06_0049AFE8.c b/src/overlays/shared/L06_0049AFE8.c
new file mode 100644
index 000000000..e1c7d1bfd
--- /dev/null
+++ b/src/overlays/shared/L06_0049AFE8.c
@@ -0,0 +1,91 @@
+#include "common.h"
+
+typedef int u128 __attribute__((mode(TI)));
+
+typedef struct {
+    s32 area0;
+    s32 area1;
+    s16 secs;
+    s16 timer;
+    u8 *from;
+    u8 *to;
+    u8 busy;
+} Vars;
+
+extern s32 D_0021E694;
+extern s32 D_0021E698;
+extern void func_0046BDD0(u8 *);
+extern void func_00473A88(u8 *, s32, s32);
+extern s32 func_00453538(s16 *);
+extern s32 func_L06_0049B248(void);
+extern u8 *func_00510BE8(s32);
+extern s32 func_0047BA40(u128, s32);
+extern s32 func_0046B5B8(u8 **, u8 *, s32);
+extern void func_0051FDC0(u8 *, u8 *, u8 *, s32, s32, s32, s32, s32);
+
+void func_L06_0049AFE8(u8 *moby) {
+    Vars *v;
+    s32 mask;
+    s32 i;
+    u8 *p;
+    u8 *out;
+
+    if (D_0021E694 != 0 || D_0021E698 != 1) {
+        func_0046BDD0(moby);
+        return;
+    }
+    v = *(Vars **)(moby + 0xAC);
+    if (moby[0x20] == 0) {
+        if (v->area0 == -1) {
+            func_0046BDD0(moby);
+            return;
+        }
+        v->busy = 0;
+        v->timer = 0;
+        func_00473A88(moby, 2, -1);
+    }
+    switch (moby[0x20]) {
+    case 1:
+        if (func_00453538(&v->timer)) {
+            func_00473A88(moby, 2, -1);
+        }
+        break;
+    case 2:
+        if (func_L06_0049B248() != 0) {
+            break;
+        }
+        mask = 0;
+        for (i = 0; i < 2; i++) {
+            if (func_0047BA40(*(u128 *)(func_00510BE8(i) + 0xA0), v->area0)) {
+                mask |= 1 << i;
+            }
+        }
+        if (mask == 0 || mask == 3) {
+            break;
+        }
+        i = mask & 1;
+        mask = 1;
+        p = func_00510BE8(i);
+        v->from = p;
+        if (v->area1 != -1 && func_0047BA40(*(u128 *)(p + 0xA0), v->area1)) {
+            break;
+        }
+        v->to = func_00510BE8(mask - i);
+        func_00473A88(moby, 3, -1);
+        break;
+    case 3:
+        if (func_L06_0049B248() != 0 ||
+            (v->area1 != -1 && func_0047BA40(*(u128 *)(v->from + 0xA0), v->area1))) {
+            func_00473A88(moby, 2, -1);
+            break;
+        }
+        v->busy = 1;
+        if (func_0046B5B8(&out, v->to, 0)) {
+            func_0051FDC0(v->from, out, out + 0x10, -1, 1, 1, 0, 1);
+            v->timer = (s32)((f32)v->secs * 60.0f);
+            func_00473A88(moby, 1, -1);
+        }
+        v->busy = 0;
+        break;
+    }
+}
diff --git a/src/overlays/shared/L06_004C7378.c b/src/overlays/shared/L06_004C7378.c
new file mode 100644
index 000000000..bb5bd53fa
--- /dev/null
+++ b/src/overlays/shared/L06_004C7378.c
@@ -0,0 +1,17 @@
+/* cflags: -O2 -G8 -Wuninitialized */
+#include "common.h"
+extern void func_0053C1C8(void *, s32, s32);
+extern void func_004C73F0(void *, s32, s32);
+extern void func_004C75C0(void *);
+void func_L06_004C7378(void *arg0)
+{
+    u8 *owner = *(u8 **)((u8 *)arg0 + 0xAC);
+    *(u16 *)((u8 *)arg0 + 0x34) |= 1;
+    *(s32 *)(owner + 0x54) = 1;
+    *(f32 *)(owner + 0x50) = 1.0f;
+    if (*(u8 *)(owner + 0xEC))
+        *(u8 *)(owner + 0xED) = 0;
+    func_004C73F0(arg0, *(u8 *)(owner + 0xEC), *(u8 *)(owner + 0xED));
+    func_004C75C0(arg0);
+    func_0053C1C8(arg0, 1, -1);
+}
diff --git a/src/overlays/shared/L06_004C8388.c b/src/overlays/shared/L06_004C8388.c
new file mode 100644
index 000000000..0cc525e38
--- /dev/null
+++ b/src/overlays/shared/L06_004C8388.c
@@ -0,0 +1,12 @@
+#include "common.h"
+
+extern s32 func_L06_004C7210(u8 *);
+extern s32 D_00222614;
+
+s32 func_L06_004C8388(void *arg0)
+{
+    u8 *state = *(u8 **)((u8 *)arg0 + 0xAC);
+    if (*(s16 *)(state + 0x8C) != -1 && *(s16 *)(state + 0x8E) == 0)
+        return 1;
+    return func_L06_004C7210((u8 *)(D_00222614 + (*(s32 *)(state + 0x6C) << 8))) != 0;
+}
diff --git a/src/overlays/shared/L06_004DE3B8.c b/src/overlays/shared/L06_004DE3B8.c
new file mode 100644
index 000000000..78ad40d46
--- /dev/null
+++ b/src/overlays/shared/L06_004DE3B8.c
@@ -0,0 +1,66 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad0[0x70];
+    s32 x70;
+    s32 x74;
+    u8 pad78[0xC];
+    s16 n;
+    u8 pad86[0x16A];
+    u8 *mobys[1];
+} Arena;
+
+extern Arena D_0023C000;
+extern u8 *D_00362B38[];
+extern s32 D_0021DE10;
+extern void func_L00_00596A28(s32, s32, s32, s32);
+extern void func_L00_00598118(s32);
+
+void func_L06_004DE3B8(void) {
+    u8 *moby;
+    u8 *m;
+    u8 *q;
+    s32 i;
+    s32 j;
+    s32 id;
+
+    for (i = 0; i < D_0023C000.n; i++) {
+        moby = D_0023C000.mobys[i];
+        if (moby != NULL) {
+            id = *(s16 *)(moby + 0xBC);
+            if (id == 0x216A || id == 0x2691 || (id == 0x2429 && D_0021DE10 == 0x2574) || id == 0x20FD || id == 0x2703 || id == 0x2505) {
+                func_L00_00596A28(i, 0x96, 0, 0);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x216A || *(s16 *)(moby + 0xBC) == 0x2691) {
+                *(u16 *)(D_0023C000.mobys[i] + 0x74) |= 0x1000;
+            }
+            if (*(s16 *)(moby + 0xBC) == 0xA) {
+                m = D_0023C000.mobys[i];
+                if (D_0023C000.x70 == 2) {
+                    *(u16 *)(m + 0x74) |= 0x1000;
+                } else {
+                    *(u16 *)(m + 0x74) |= 0x1002;
+                }
+                func_L00_00596A28(i, 0x6E, 0x80306629, 0x8058B856);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x243D) {
+                func_L00_00596A28(i, 0x168, 0xC0808080, 0x80505050);
+            }
+            if (*(s16 *)(moby + 0xBC) == 0x247F || *(s16 *)(moby + 0xBC) == 0x24D9 || *(s16 *)(moby + 0xBC) == 0x24D5) {
+                func_L00_00596A28(i, 0x5A, 0xFFC0C0C0, 0xB0505050);
+            }
+        }
+    }
+    if (D_0023C000.x70 == 3 && D_0023C000.x74 < 0xA0) {
+        func_L00_00598118(0);
+    }
+    if (D_0023C000.x70 == 4 && D_0023C000.x74 >= 0x65) {
+        func_L00_00598118(0);
+    }
+    func_L00_00598118(0);
+    for (j = 0, q = D_00362B38[0]; j < 10; q = D_00362B38[++j]) {
+        if (q != NULL) {
+            (*(u8 **)(q + 0x2EF0))[0x31] = 0;
+        }
+    }
+}
diff --git a/src/overlays/shared/L06_00565628.c b/src/overlays/shared/L06_00565628.c
new file mode 100644
index 000000000..be785d06b
--- /dev/null
+++ b/src/overlays/shared/L06_00565628.c
@@ -0,0 +1,25 @@
+#include "common.h"
+
+extern void func_L00_00601788(void);
+extern s32 D_00222700;
+
+s32 func_L06_00565628(u16 a1)
+{
+    s32 result;
+    s32 v2;
+
+    if (!D_00222700)
+        return 0;
+    result = 0;
+    if (*(s32 *)(D_00222700 + 12308) >= (s64)a1) {
+        v2 = *(u32 *)(D_00222700 + 12312) + 32 * a1;
+        if (((*(u8 *)(v2 + 2) ^ 1) & 1) != 0) {
+            return 0;
+        } else {
+            *(u16 *)(v2 + 2) &= ~1u;
+            func_L00_00601788();
+            return 1;
+        }
+    }
+    return result;
+}
diff --git a/src/overlays/shared/L10_004DCC58.c b/src/overlays/shared/L10_004DCC58.c
new file mode 100644
index 000000000..0e22c5eb3
--- /dev/null
+++ b/src/overlays/shared/L10_004DCC58.c
@@ -0,0 +1,17 @@
+#include "common.h"
+
+extern void func_005444C8(void *);
+extern void func_00473A88(void *, s32, s32);
+
+void func_L10_004DCC58(u8 *arg0) {
+    u8 *vars = *(u8 **)(arg0 + 0xAC);
+
+    *(s16 *)(vars + 0x76) = (f32)*(s16 *)(vars + 0x74) * 60.0f;
+    func_005444C8(arg0);
+    arg0[0x30] = 0xFF;
+    if (*(s32 *)(vars + 0x78) != 0) {
+        func_00473A88(arg0, 1, -1);
+    } else {
+        func_00473A88(arg0, 2, -1);
+    }
+}
diff --git a/src/overlays/shared/L11_003FEB88.c b/src/overlays/shared/L11_003FEB88.c
new file mode 100644
index 000000000..57cdca22e
--- /dev/null
+++ b/src/overlays/shared/L11_003FEB88.c
@@ -0,0 +1,17 @@
+/* cflags:  */
+#include "common.h"
+
+s32 func_L11_003FE6D0(s32 arg0);
+s32 D_00220EA0 = 0;
+
+s32 func_L11_003FEB88(void)
+{
+    s32 i;
+    s32 result;
+
+    for (i = D_00220EA0; i; i = *(u32 *)(result + 100)) {
+        func_L11_003FE6D0(i);
+        result = *(s32 *)(i + 172);
+    }
+    return result;
+}
diff --git a/src/overlays/shared/L11_00492768.c b/src/overlays/shared/L11_00492768.c
new file mode 100644
index 000000000..c52404d66
--- /dev/null
+++ b/src/overlays/shared/L11_00492768.c
@@ -0,0 +1,56 @@
+#include "common.h"
+
+typedef struct {
+    u8 pad0[0x3C];
+    u8 *moby;
+} Target;
+
+typedef struct {
+    u8 pad0[0x18];
+    u8 *last;
+    u8 pad1C[8];
+    s16 timer;
+} Hits;
+
+extern Target D_0023EE80[];
+
+extern void func_00541E10(u8 *, u8 *);
+extern s32 func_00508988(s16 *);
+extern u8 *func_0053F490(u8 *, s32, s32);
+extern s32 func_00492888(u8 *);
+extern void func_00541BE8(u8 *, s32, s32, s32);
+
+f32 func_L11_00492768(u8 *moby) {
+    u8 *vars = *(u8 **)(moby + 0xAC);
+    Hits *h;
+    u8 *hit;
+
+    func_00541E10(moby, NULL);
+    h = (Hits *)(vars + 0x50);
+    if (h->last != NULL) {
+        if (h->last[0x20] == 0xFE) {
+            goto clear;
+        }
+        if (h->last[0x20] == 0xFD) {
+            goto clear;
+        }
+    }
+    if (func_00508988((s16 *)(vars + 0x74)) != 0) {
+    clear:
+        h->last = NULL;
+    }
+    if (moby[0x2C] == 0xFF || (&D_0023EE80[0] + moby[0x2C])->moby != moby) {
+        hit = NULL;
+    } else {
+        hit = func_0053F490(moby, 0x0FFFFFFF, 0);
+    }
+    moby[0x2C] = 0xFF;
+    if (hit != NULL && *(u8 **)(hit + 0x20) != NULL && func_00492888(*(u8 **)(hit + 0x20)) != 0 &&
+        h->last != *(u8 **)(hit + 0x20)) {
+        h->last = *(u8 **)(hit + 0x20);
+        h->timer = 0x78;
+        func_00541BE8(moby, 1, 0, 0);
+        return *(f32 *)(hit + 0x2C);
+    }
+    return 0.0f;
+}
diff --git a/src/overlays/shared/L13_004BD628.c b/src/overlays/shared/L13_004BD628.c
new file mode 100644
index 000000000..279a5da14
--- /dev/null
+++ b/src/overlays/shared/L13_004BD628.c
@@ -0,0 +1,46 @@
+#include "common.h"
+
+extern s32 func_0054B220(u8 *);
+extern void func_00556700(u8 *, s32, s32, f32, s32);
+extern void func_00556808(u8 *, s32, s32);
+extern void func_0054B1C0(u8 *, s32);
+extern void func_005EABA8(s32, s32, u8 *);
+
+void func_L13_004BD628(u8 *moby) {
+    switch (moby[0x20]) {
+    case 0:
+        if (func_0054B220(moby) != 0) {
+            func_00556700(moby, 2, 0, 0.0f, 0);
+            func_00556808(moby, 4, -1);
+        } else {
+            func_00556700(moby, 0, 0, 0.0f, 0);
+            func_00556808(moby, 1, -1);
+        }
+        break;
+    case 1:
+        if (moby[0xBE] & 4) {
+            func_0054B1C0(moby, 1);
+            func_00556808(moby, 2, -1);
+        }
+        break;
+    case 2:
+        if (++*(u16 *)(moby + 0x6A) == 0x5A) {
+            func_005EABA8(0, 0x130, moby);
+            func_00556700(moby, 1, 0, 0.0f, 0);
+            func_00556808(moby, 3, -1);
+        }
+        break;
+    case 3:
+        moby[0x55] |= 0x10;
+        if (moby[0x55] & 2) {
+            func_00556700(moby, 2, 0, 0.0f, 0);
+            *(f32 *)(moby + 0x48) = 0.0f;
+            func_00556808(moby, 4, -1);
+        }
+        break;
+    case 4:
+        *(s32 *)(moby + 0x98) = 0;
+        *(u16 *)(moby + 0x34) |= 2;
+        break;
+    }
+}
diff --git a/src/overlays/shared/L41_0043A858.c b/src/overlays/shared/L41_0043A858.c
new file mode 100644
index 000000000..016579abe
--- /dev/null
+++ b/src/overlays/shared/L41_0043A858.c
@@ -0,0 +1,83 @@
+#include "common.h"
+
+typedef struct C_0043A858 {
+    u8 pad0[0x24];
+    f32 unk24;
+} C_0043A858;
+
+typedef struct M_0043A858 {
+    u8 pad0[0x24];
+    C_0043A858 *unk24;
+    u8 pad28[0x38 - 0x28];
+    s64 unk38;
+    u8 pad40[0x64 - 0x40];
+    u8 unk64;
+    u8 unk65;
+    u8 pad66[0x70 - 0x66];
+    f32 unk70;
+    u8 pad74[0xAC - 0x74];
+    void *unkAC;
+    u8 padB0[0xBC - 0xB0];
+    s16 unkBC;
+} M_0043A858;
+
+typedef struct V_0043A858 {
+    s32 unk0;
+    M_0043A858 *unk4;
+    u8 pad8[0x20 - 0x8];
+    M_0043A858 *unk20;
+    u8 pad24[0x40 - 0x24];
+    f32 unk40;
+} V_0043A858;
+
+typedef struct W_0043A858 {
+    u8 pad0[0x33C];
+    M_0043A858 *unk33C;
+} W_0043A858;
+
+typedef struct A_0043A858 {
+    u8 pad0[0xAC];
+    V_0043A858 *unkAC;
+} A_0043A858;
+
+extern M_0043A858 *func_L00_005DD000(s32, s32);
+extern void func_L00_005EEA48(M_0043A858 *, M_0043A858 *, s32, s32);
+extern void func_L00_005F1180(M_0043A858 *, M_0043A858 *);
+extern void func_L00_007011A8(M_0043A858 *, s32, s32);
+extern s32 func_L01_004DE8B0(A_0043A858 *);
+extern s32 func_L41_0043A5A8(s32);
+
+void func_L41_0043A858(A_0043A858 *arg0) {
+    V_0043A858 *v;
+    M_0043A858 *target;
+    M_0043A858 *m;
+    W_0043A858 *w;
+    s32 r;
+
+    v = arg0->unkAC;
+    target = v->unk4;
+    if (func_L01_004DE8B0(arg0) != 0 || target == NULL) {
+        return;
+    }
+    r = func_L41_0043A5A8(v->unk0);
+    if (r == 0) {
+        return;
+    }
+    if (target->unkBC == 0x2106) {
+        v->unk20 = func_L00_005DD000(0x210B, 0);
+        if (v->unk20 != NULL) {
+            func_L00_005F1180(v->unk20, target);
+            v->unk20->unk38 = target->unk38;
+            v->unk20->unk64 = 0;
+            v->unk20->unk65 = 10;
+            w = target->unkAC;
+            if (w != NULL) {
+                w->unk33C = v->unk20;
+            }
+            m = v->unk20;
+            m->unk70 = m->unk24->unk24 * (2.0f * v->unk40 * 1.375f);
+            func_L00_005EEA48(target, v->unk20, 1, 0);
+        }
+    }
+    func_L00_007011A8(target, r, 0);
+}
diff --git a/src/overlays/shared/L41_004484C8.c b/src/overlays/shared/L41_004484C8.c
new file mode 100644
index 000000000..9fb05b547
--- /dev/null
+++ b/src/overlays/shared/L41_004484C8.c
@@ -0,0 +1,85 @@
+#include "common.h"
+
+typedef struct C_004484C8 {
+    u8 pad0[0x24];
+    f32 unk24;
+} C_004484C8;
+
+typedef struct M_004484C8 {
+    u8 pad0[0x24];
+    C_004484C8 *unk24;
+    u8 pad28[0x38 - 0x28];
+    s64 unk38;
+    u8 pad40[0x64 - 0x40];
+    u8 unk64;
+    u8 unk65;
+    u8 pad66[0x70 - 0x66];
+    f32 unk70;
+    u8 pad74[0xAC - 0x74];
+    void *unkAC;
+    u8 padB0[0xBC - 0xB0];
+    s16 unkBC;
+} M_004484C8;
+
+typedef struct V_004484C8 {
+    u8 pad0[0x10];
+    s32 unk10;
+    u8 pad14[0x18 - 0x14];
+    M_004484C8 *unk18;
+    M_004484C8 *unk1C;
+} V_004484C8;
+
+typedef struct W_004484C8 {
+    u8 pad0[0x33C];
+    M_004484C8 *unk33C;
+} W_004484C8;
+
+typedef struct A_004484C8 {
+    u8 pad0[0xAC];
+    V_004484C8 *unkAC;
+} A_004484C8;
+
+extern s32 func_00446418(s32);
+extern M_004484C8 *func_L00_005DD000(s32, s32);
+extern void func_L00_005DD4A0(M_004484C8 *);
+extern void func_L00_005EEA48(M_004484C8 *, M_004484C8 *, s32, s32);
+extern void func_L00_005F1180(M_004484C8 *, M_004484C8 *);
+extern void func_L00_007011A8(M_004484C8 *, s32, s32);
+
+void func_L41_004484C8(A_004484C8 *arg0) {
+    V_004484C8 *v;
+    M_004484C8 *target;
+    M_004484C8 *m;
+    W_004484C8 *w;
+    s32 r;
+
+    v = arg0->unkAC;
+    target = v->unk18;
+    if (target == NULL) {
+        return;
+    }
+    r = func_00446418(v->unk10);
+    if (r == 0) {
+        return;
+    }
+    if (target->unkBC == 0x2106) {
+        if (v->unk1C != NULL) {
+            func_L00_005DD4A0(v->unk1C);
+        }
+        v->unk1C = func_L00_005DD000(0x210B, 0);
+        if (v->unk1C != NULL) {
+            v->unk1C->unk64 = 0;
+            v->unk1C->unk65 = 10;
+            func_L00_005F1180(v->unk1C, target);
+            v->unk1C->unk38 = target->unk38;
+            w = target->unkAC;
+            if (w != NULL) {
+                w->unk33C = v->unk1C;
+            }
+            m = v->unk1C;
+            m->unk70 = m->unk24->unk24 * 1.6500001f;
+            func_L00_005EEA48(target, v->unk1C, 1, 0);
+        }
+    }
+    func_L00_007011A8(target, r, 0);
+}
diff --git a/src/overlays/shared/L41_00625710.c b/src/overlays/shared/L41_00625710.c
new file mode 100644
index 000000000..ca777477b
--- /dev/null
+++ b/src/overlays/shared/L41_00625710.c
@@ -0,0 +1,40 @@
+/* cflags: -G0 */
+#include "common.h"
+
+typedef struct {
+    s32 id;
+    s32 a;
+    s32 b;
+    s32 kind;
+} Entry;
+
+extern void func_L41_006255D0(void);
+extern Entry D_0036E050[16];
+
+void func_L41_00625710(s32 id, s32 val, s32 kind) {
+    s32 i;
+    s32 slot;
+
+    slot = -1;
+    if (kind == 10) {
+        return;
+    }
+    for (i = 0; i < 16; i++) {
+        if (D_0036E050[i].id == id) {
+            slot = i;
+            break;
+        }
+        if (D_0036E050[i].id == -1 && slot == -1) {
+            slot = i;
+        }
+    }
+    if (slot >= 0) {
+        if (D_0036E050[slot].kind != kind) {
+            func_L41_006255D0();
+        }
+        D_0036E050[slot].id = id;
+        D_0036E050[slot].a = val;
+        D_0036E050[slot].b = val;
+        D_0036E050[slot].kind = kind;
+    }
+}
diff --git a/src/pal/core/0013A0F0.c b/src/pal/core/0013A0F0.c
deleted file mode 100644
index 753fafb9f..000000000
--- a/src/pal/core/0013A0F0.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/* cflags: @ee29 -O2 -G0 */
-#include "common.h"
-
-extern s32 D_00167C7C[];
-extern s32 D_00167C80[];
-extern s32 func_0013A7A0(s32 nonblocking, s32 *command, s32 *result);
-extern s32 func_00126BB0(s32 semaphore);
-
-s32 func_0013A0F0(void)
-{
-    if (D_00167C7C[0] >= 0) {
-        func_0013A7A0(0, 0, 0);
-        func_00126BB0(D_00167C7C[0]);
-        D_00167C7C[0] = -1;
-        func_00126BB0(D_00167C80[0]);
-    }
-    return 1;
-}
diff --git a/src/pal/core/001464C0.c b/src/pal/core/001464C0.c
deleted file mode 100644
index bf758d8c1..000000000
--- a/src/pal/core/001464C0.c
+++ /dev/null
@@ -1,10 +0,0 @@
-/* cflags: @ee29 -O2 -G0 */
-#include "common.h"
-
-extern const char D_001957F0[];
-extern void func_001294F0(const char *format, ...);
-
-void func_001464C0(const char *message)
-{
-    func_001294F0(D_001957F0, message);
-}
diff --git a/src/pal/game/00405D38.c b/src/pal/game/00405D38.c
new file mode 100644
index 000000000..7c93391a1
--- /dev/null
+++ b/src/pal/game/00405D38.c
@@ -0,0 +1,24 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+u32 func_00405D38(s32 value) {
+    u32 out;
+    s32 top;
+    s32 nib;
+    s32 high;
+    s32 i;
+
+    out = 0;
+    top = value >> 28;
+    nib = 0xF;
+    nib = top & nib;
+    if ((top & 7) != 0) {
+        high = nib - (nib & 8);
+    } else {
+        high = 5;
+    }
+    for (i = 0; i < 7; i++) {
+        out |= ((value >> (i * 4)) & 7) << (i * 4);
+    }
+    return (out & 0xFFFFFFF) | (high << 28);
+}
diff --git a/src/pal/game/004071B0.c b/src/pal/game/004071B0.c
new file mode 100644
index 000000000..25e486998
--- /dev/null
+++ b/src/pal/game/004071B0.c
@@ -0,0 +1,27 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+typedef struct Type1 Type1;
+typedef struct Type2 Type2;
+struct Type2 {
+    char _p0[0x10];
+    s32 (*f14)();
+};
+struct Type1 {
+    char _p0[0xC];
+    Type2 *f10;
+    char _p14[0xC];
+    s32 f20;
+};
+
+s32 func_00408260(s32);
+
+s32 func_004071B0(Type1 *arg0) {
+    s32 temp_v0;
+
+    temp_v0 = arg0->f10->f14(arg0->f20);
+    if (temp_v0 != 0) {
+        return func_00408260(temp_v0);
+    }
+    return 0;
+}
diff --git a/src/pal/game/00407408.c b/src/pal/game/00407408.c
new file mode 100644
index 000000000..92490d322
--- /dev/null
+++ b/src/pal/game/00407408.c
@@ -0,0 +1,27 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+typedef struct Type1 Type1;
+typedef struct Type2 Type2;
+struct Type2 {
+    char _p0[0x14];
+    s32 (*f14)();
+};
+struct Type1 {
+    char _p0[0xC];
+    Type2 *f10;
+    char _p14[0xC];
+    s32 f20;
+};
+
+s32 func_00408260(s32);
+
+s32 func_00407408(Type1 *arg0) {
+    s32 temp_v0;
+
+    temp_v0 = arg0->f10->f14(arg0->f20);
+    if (temp_v0 != 0) {
+        return func_00408260(temp_v0);
+    }
+    return 0;
+}
diff --git a/src/pal/game/004074A8.c b/src/pal/game/004074A8.c
new file mode 100644
index 000000000..ebdd3a731
--- /dev/null
+++ b/src/pal/game/004074A8.c
@@ -0,0 +1,27 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+typedef struct Type1 Type1;
+typedef struct Type2 Type2;
+struct Type2 {
+    char _p0[0xC];
+    s32 (*f14)();
+};
+struct Type1 {
+    char _p0[0xC];
+    Type2 *f10;
+    char _p14[0xC];
+    s32 f20;
+};
+
+s32 func_00408260(s32);
+
+s32 func_004074A8(Type1 *arg0) {
+    s32 temp_v0;
+
+    temp_v0 = arg0->f10->f14(arg0->f20);
+    if (temp_v0 != 0) {
+        return func_00408260(temp_v0);
+    }
+    return 0;
+}
diff --git a/src/pal/game/00484F88.c b/src/pal/game/00484F88.c
new file mode 100644
index 000000000..218f4c134
--- /dev/null
+++ b/src/pal/game/00484F88.c
@@ -0,0 +1,22 @@
+#include "common.h"
+
+extern f32 func_L00_005FCB68(u8 *);
+
+s32 func_00484F88(u8 *moby, f32 value) {
+    f32 cur = func_L00_005FCB68(moby);
+    f32 len = *(f32 *)(moby + 0x48);
+    s32 v = (s32)(value * 4096.0f + 0.5f);
+    s32 lo = (s32)(cur * 4096.0f + 0.5f);
+    s32 hi = (s32)((cur - len * 1.2f * 0.5f) * 4096.0f + 0.5f);
+
+    if (len < 0.0f) {
+        if (v >= lo && v < hi) {
+            return 1;
+        }
+        return 0;
+    }
+    if (v <= lo && v > hi) {
+        return 1;
+    }
+    return 0;
+}
diff --git a/src/pal/game/004AA180.c b/src/pal/game/004AA180.c
new file mode 100644
index 000000000..05e7c0ce0
--- /dev/null
+++ b/src/pal/game/004AA180.c
@@ -0,0 +1,21 @@
+#include "common.h"
+
+typedef struct {
+    char pad[0x98];
+    s32 flags;
+    f32 f9C;
+    char tail[0x18];
+} Type1;
+extern Type1 D_00308208[];
+extern f32 func_004760C0(f32 *value, f32 target, f32 fraction, f32 minimum);
+extern u8 func_00498E38(s32 arg0);
+extern s32 func_00506BB8(void);
+
+void func_004AA180(void)
+{
+    s32 index = func_00506BB8();
+    Type1 *p = (Type1 *)((u32)index * 0xB8 + (u32)D_00308208);
+    if (func_004760C0(&p->f9C, (f32)func_00498E38(index), 0.0f, 0.24000001f) != 0.0f) {
+        D_00308208[index].flags |= 0x100;
+    }
+}
diff --git a/src/pal/game/004AF7A0.c b/src/pal/game/004AF7A0.c
new file mode 100644
index 000000000..3d58c3313
--- /dev/null
+++ b/src/pal/game/004AF7A0.c
@@ -0,0 +1,85 @@
+#include "common.h"
+typedef struct { s32 a; s32 b; u8 c; u8 pad[3]; } Entry;
+typedef struct { s32 a; s32 b; } Pair;
+typedef struct { s32 pad[10]; s32 active[4]; s32 pad2[4]; s32 timer[4]; } State;
+extern Entry D_003D9318[];
+extern u8 D_003093A0[];
+extern s32 D_0021EE54;
+extern s32 D_0021EE58;
+extern s32 D_0021DE98;
+extern s32 D_002217C0;
+extern s32 D_00221318;
+extern s32 D_001F1480[];
+extern u32 D_0021DAF0;
+s32 D_0021F73C = 0;
+extern void func_00449A28(s32 *a, void (*b)(void *), s32 c);
+extern s32 func_00453CE8(s32 *arg0);
+extern void func_0045E168(s32, s32, s32);
+extern void func_0045E288(s32, s32, s32, s32);
+extern void func_0045E2D8(s32, s32, s32, s32);
+extern s32 func_0047CD08(Pair *out, s32 i, s32 b);
+extern void func_0047CA28(void *);
+extern u8 *func_0047DE20(void);
+extern s32 func_00506BB8(void);
+
+void func_004AF7A0(void)
+{
+    State *flags = (State *)(D_003093A0 + func_00506BB8() * 0x64);
+    Pair cur;
+    s32 i;
+
+    if (D_0021EE54 == 0 && D_0021EE58 == 0) {
+        if (func_00453CE8(&D_002217C0)) {
+            D_002217C0 = 0x14;
+            for (i = 0; i < 4; i++) {
+                if (flags->active[i] != 0)
+                    continue;
+                if (func_0047CD08(&cur, i, D_003D9318[i].b)) {
+                    switch (cur.a) {
+                    case 2:
+                        func_0045E288(0x3460, 0x7F1, 0x3E8, 2);
+                        break;
+                    case 10:
+                        if ((u32)D_001F1480[0x4ED0 / 4] < D_0021DAF0)
+                            D_001F1480[0x4ED0 / 4] = D_0021DAF0;
+                        break;
+                    case 11:
+                        if (D_0021DAF0 - D_001F1480[0x4ED0 / 4] < 0x1388)
+                            func_0045E168(0x333A, 0x785, 2);
+                        break;
+                    case 5:
+                        func_0045E288(0x292A, 0x2A1, 0x15E, 2);
+                        break;
+                    case 6:
+                        func_0045E288(0x292E, 0x2A5, 0x1F4, 2);
+                        break;
+                    case 12:
+                        break;
+                    case 9:
+                        if (D_0021DE98 != 1)
+                            func_0045E168(0x2987, 0x2FE, 2);
+                        func_0045E2D8(0x3202, 0x709, 0x5DC, 2);
+                        break;
+                    }
+                    if (D_003D9318[i].a != cur.a || D_003D9318[i].b != cur.b) {
+                        D_003D9318[i].a = cur.a;
+                        D_003D9318[i].b = cur.b;
+                        if (D_003D9318[i].a != 1)
+                            flags->timer[i] = 0x5A;
+                    }
+                    if (D_003D9318[i].a == 9) {
+                        if (func_0047DE20()[3] == 0)
+                            flags->timer[i] = 0x5A;
+                    }
+                } else {
+                    D_003D9318[i].a = 0;
+                    D_003D9318[i].b = 0;
+                    flags->timer[i] = 0;
+                }
+            }
+        }
+        if (D_003D9318[3].a == 2)
+            func_00449A28(&D_00221318, func_0047CA28, D_003D9318[3].b);
+    }
+    D_0021F73C |= 2;
+}
diff --git a/src/pal/game/004CEB68.c b/src/pal/game/004CEB68.c
deleted file mode 100644
index 3992edced..000000000
--- a/src/pal/game/004CEB68.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "common.h"
-
-extern u8 D_0030ECC0[];
-extern s32 D_00171C88[];
-
-s32 func_00506BB8(void);
-void func_00502520(void *);
-void func_004CEFD0(void);
-void func_004CED68(void);
-void func_004CEDA8(void);
-s32 func_004A2468(void *);
-void func_004CEE80(void);
-
-void func_004CEB68(void *arg0) {
-    s32 index;
-    s32 record;
-    s32 valueAddress;
-    s32 value;
-    s32 state;
-
-    index = func_00506BB8();
-    record = (s32)D_0030ECC0 + index * 0x280;
-    valueAddress = (s32)D_0030ECC0 + 0x27C + index * 0x280;
-    value = *(s32 *)valueAddress;
-    if (value != -1) {
-        if (value >= 0) {
-            D_00171C88[(u32)value >> 5] &= ~(1 << (value & 0x1F));
-        }
-        *(s32 *)valueAddress = -1;
-    }
-    state = *(s32 *)record;
-    switch (state) {
-        case 1:
-            *(s32 *)record = 0;
-            break;
-        case 2:
-            func_00502520(arg0);
-            break;
-        case 0:
-            func_004CEFD0();
-            break;
-    }
-    if ((*(s32 *)(record + 8) & 1) != 0) {
-        func_004CED68();
-    }
-    if ((*(s32 *)(record + 8) & 2) != 0) {
-        func_004CEDA8();
-    }
-    func_004A2468((void *)(record + 0x210));
-    state = *(s32 *)(record + 8);
-    state &= 4;
-    if (state != 0) {
-        func_004CEE80();
-    }
-}
diff --git a/src/pal/game/004DA960.c b/src/pal/game/004DA960.c
deleted file mode 100644
index 34644a146..000000000
--- a/src/pal/game/004DA960.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "common.h"
-typedef struct {
-    s32 a, b;
-    void *data;
-    char tail[12];
-} Item;
-typedef struct {
-    char pad[0x34];
-    Item *items;
-    char gap[0x18];
-    s32 count, index;
-} List;
-typedef struct {
-    s32 a, b, flags;
-    char pad[0xA8];
-    List list;
-    char gap[0x14];
-    s32 handle;
-} State;
-extern State D_00321650[];
-extern char D_001CE230[];
-extern s32 D_00221C68;
-extern s32 func_00506BB8(void), func_0049A9D8(void *, s32), func_004A2798(s32 *, s32), func_005071B8(s32, s32);
-extern void func_0049AA18(s32);
-static inline Item *selected(List *l)
-{
-    if (l->index < 0)
-        return 0;
-    return l->items + l->index;
-}
-void func_004DA960(void)
-{
-    State *p = D_00321650 + func_00506BB8();
-    List *l = &p->list;
-    if (l->count > 0) {
-        if (p->handle) {
-            func_0049AA18(p->handle);
-            p->handle = 0;
-        }
-        p->handle = func_0049A9D8(D_001CE230 + *(s32 *)selected(l)->data * 8, -1);
-        func_005071B8(func_004A2798(&D_00221C68, 4), p->handle);
-    }
-    p->flags &= ~2;
-}
diff --git a/src/pal/game/00505148.c b/src/pal/game/00505148.c
new file mode 100644
index 000000000..7842d0fa7
--- /dev/null
+++ b/src/pal/game/00505148.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00222138[];
+extern Manager *func_00502150(void);
+extern Allocator *func_00502218(Manager *, s32);
+extern void func_005052C0(s32);
+extern s32 func_005052C8(void);
+extern s32 func_00500980(void *, u32);
+extern void *func_0015DB90(u32, void *);
+extern Object *func_0050EB78(void *);
+extern s32 func_00501618(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00222138;
+    if (manager->table) {
+        return manager;
+    }
+    return func_00502150();
+}
+
+s32 func_00505148(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_005052C0(0x208);
+    size = func_005052C8();
+    if (entry != NULL && func_00500980(entry, key) == 0) {
+        allocator = func_00502218(get_manager(), 0x4);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_0050EB78(func_0015DB90(0x208, block));
+            result = func_00501618(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_00502218(get_manager(), 0x4);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/pal/game/00509248.c b/src/pal/game/00509248.c
new file mode 100644
index 000000000..7282b8b63
--- /dev/null
+++ b/src/pal/game/00509248.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00222138[];
+extern Manager *func_00502150(void);
+extern Allocator *func_00502218(Manager *, s32);
+extern void func_005052C0(s32);
+extern s32 func_005052C8(void);
+extern s32 func_00500980(void *, u32);
+extern void *func_0015DB90(u32, void *);
+extern Object *func_00511678(void *);
+extern s32 func_00501618(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00222138;
+    if (manager->table) {
+        return manager;
+    }
+    return func_00502150();
+}
+
+s32 func_00509248(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_005052C0(0x50);
+    size = func_005052C8();
+    if (entry != NULL && func_00500980(entry, key) == 0) {
+        allocator = func_00502218(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_00511678(func_0015DB90(0x50, block));
+            result = func_00501618(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_00502218(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/pal/game/00522238.c b/src/pal/game/00522238.c
new file mode 100644
index 000000000..6011201db
--- /dev/null
+++ b/src/pal/game/00522238.c
@@ -0,0 +1,19 @@
+#include "common.h"
+
+s32 func_005210B0(void);
+extern s32 func_00522238(void);
+extern s32 func_005210B0(void);
+
+s32 func_00522238(void) {
+    s32 n = 0xA;
+    s32 x = func_005210B0();
+    goto test;
+zero:
+    n = 0;
+    goto done;
+test:
+    if (x == 2)
+        goto zero;
+done:
+    return n;
+}
diff --git a/src/pal/game/005230A8.c b/src/pal/game/005230A8.c
new file mode 100644
index 000000000..1654badd6
--- /dev/null
+++ b/src/pal/game/005230A8.c
@@ -0,0 +1,81 @@
+#include "common.h"
+
+typedef struct {
+    f32 f0;
+    s32 f4;
+    s32 f8;
+    s32 fC;
+} Type1;
+
+typedef struct {
+    u8 pad0[0x3CA];
+    s16 f3CA;
+    u8 pad3CC[0x648 - 0x3CC];
+    s32 f648;
+    u8 pad64C[0x2318 - 0x64C];
+    s32 f2318;
+    u8 pad231C[0x265A - 0x231C];
+    u8 f265A;
+    u8 pad265B[0x2D7C - 0x265B];
+    Type1 f2D7C[4];
+} Type2;
+
+extern f32 func_004725D8(f32 a0, f32 a1);
+extern s32 func_00512610(Type2 *p);
+extern s32 D_0021EDD4;
+
+s32 func_005230A8(Type2 *p, s32 *out)
+{
+    s32 idx[20];
+    s32 n;
+    s32 i;
+    f32 sum;
+    f32 lim;
+
+    n = 0;
+    if (p->f3CA != 0) {
+        return 0;
+    }
+    if (p->f265A != 0) {
+        return 0;
+    }
+    if (p->f2318 == 2) {
+        return 0;
+    }
+    if (D_0021EDD4 != 1) {
+        if (func_00512610(p) != 0) {
+            *out = 3;
+            if (p->f2D7C[3].f8 != 0) {
+                return 0;
+            }
+            if (!(p->f648 & 2)) {
+                return 0;
+            }
+            return func_004725D8(0.0f, 1.0f) < 0.33f;
+        }
+    }
+    for (i = 0; i < 4; i++) {
+        if (p->f2D7C[i].f8 == 0 && p->f2D7C[i].f0 != 0.0f && (i != 2 && i != 3)) {
+            idx[n++] = i;
+        }
+    }
+    if (n == 0) {
+        return 0;
+    }
+    sum = 0.0f;
+    for (i = 0; i < n; i++) {
+        sum += 1.0f / (f32)(s32)(p->f2D7C[idx[i]].f0 * 50.0f);
+    }
+    lim = func_004725D8(0.0f, 1.0f);
+    if (lim < sum) {
+        for (i = 0; i < n; i++) {
+            *out = idx[i];
+            sum -= 1.0f / (f32)(s32)(p->f2D7C[idx[i]].f0 * 50.0f);
+            if (sum < lim) {
+                break;
+            }
+        }
+        return 1;
+    }
+    return 0;
+}
diff --git a/src/pal/game/005237C8.c b/src/pal/game/005237C8.c
new file mode 100644
index 000000000..1fc640c54
--- /dev/null
+++ b/src/pal/game/005237C8.c
@@ -0,0 +1,55 @@
+/* cflags: -ffast-math */
+#include "common.h"
+typedef unsigned int u128 __attribute__((mode(TI)));
+
+typedef struct Type1 Type1;
+typedef struct Type2 Type2;
+typedef struct Type3 Type3;
+struct Type2 {
+    char _p0[0x3C];
+    s32 (*f3C)(Type1 *, s32, s32, s32, s32);
+};
+struct Type3 {
+    char _p0[0x30];
+    s16 f30;
+};
+
+extern u128 func_004FF0F0(u128, f32);
+extern void func_005179B0(Type1 *arg0);
+extern void func_00524030(void *, s32, s32, s32, f32);
+extern Type3 *func_0054A290(s32 arg0, s32 arg1);
+extern f32 D_0021DE7C;
+
+s32 func_005237C8(u8 *p)
+{
+    s32 id;
+    s32 v;
+    f32 k;
+    f32 lim;
+
+    if (p[0x265A] == 0 || p[0x2658] == 0 || p[0x2660] != 0) {
+        return 0;
+    }
+    id = -1;
+    if (*(s32 *)(p + 0x2314) == 2) {
+        id = *(s32 *)(p + 0x2318);
+    }
+    if (id == *(s32 *)(p + 0x2DD8)) {
+        if (*(s32 *)(p + 0x60C) < 5) {
+            return 0;
+        }
+        v = func_0054A290(id, 0)->f30;
+        if ((*(Type2 **)(p + 0x14))->f3C((Type1 *)p, 0, 0, 0, 1) != 0) {
+            k = 1.5f;
+            *(u128 *)(p + 0x1A0) = func_004FF0F0(*(u128 *)(p + 0x1A0), D_0021DE7C * k * *(f32 *)(p + 0x25C4));
+            lim = D_0021DE7C * k * *(f32 *)(p + 0x25C4);
+            *(f32 *)(p + 0x1784) = lim < *(f32 *)(p + 0x1784) ? lim : *(f32 *)(p + 0x1784);
+            func_00524030(p, v, 0, 0, 9.0f);
+            *(s32 *)(p + 0x2DD4) = v;
+            return 1;
+        }
+    } else {
+        func_005179B0((Type1 *)p);
+    }
+    return 0;
+}
diff --git a/src/pal/overlays/l00_multiplayer_menu/L00_0051E6D8.c b/src/pal/overlays/l00_multiplayer_menu/L00_0051E6D8.c
new file mode 100644
index 000000000..677334d0e
--- /dev/null
+++ b/src/pal/overlays/l00_multiplayer_menu/L00_0051E6D8.c
@@ -0,0 +1,24 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+u32 func_L00_0051E6D8(s32 value) {
+    u32 out;
+    s32 top;
+    s32 nib;
+    s32 high;
+    s32 i;
+
+    out = 0;
+    top = value >> 28;
+    nib = 0xF;
+    nib = top & nib;
+    if ((top & 7) != 0) {
+        high = nib - (nib & 8);
+    } else {
+        high = 5;
+    }
+    for (i = 0; i < 7; i++) {
+        out |= ((value >> (i * 4)) & 7) << (i * 4);
+    }
+    return (out & 0xFFFFFFF) | (high << 28);
+}
diff --git a/src/pal/overlays/l00_multiplayer_menu/L00_00546148.c b/src/pal/overlays/l00_multiplayer_menu/L00_00546148.c
new file mode 100644
index 000000000..575d990f9
--- /dev/null
+++ b/src/pal/overlays/l00_multiplayer_menu/L00_00546148.c
@@ -0,0 +1,24 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+u32 func_L00_00546148(s32 value) {
+    u32 out;
+    s32 top;
+    s32 nib;
+    s32 high;
+    s32 i;
+
+    out = 0;
+    top = value >> 28;
+    nib = 0xF;
+    nib = top & nib;
+    if ((top & 7) != 0) {
+        high = nib - (nib & 8);
+    } else {
+        high = 5;
+    }
+    for (i = 0; i < 7; i++) {
+        out |= ((value >> (i * 4)) & 7) << (i * 4);
+    }
+    return (out & 0xFFFFFFF) | (high << 28);
+}
diff --git a/src/pal/overlays/l00_multiplayer_menu/L00_00565650.c b/src/pal/overlays/l00_multiplayer_menu/L00_00565650.c
new file mode 100644
index 000000000..712a52f23
--- /dev/null
+++ b/src/pal/overlays/l00_multiplayer_menu/L00_00565650.c
@@ -0,0 +1,24 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+u32 func_L00_00565650(s32 value) {
+    u32 out;
+    s32 top;
+    s32 nib;
+    s32 high;
+    s32 i;
+
+    out = 0;
+    top = value >> 28;
+    nib = 0xF;
+    nib = top & nib;
+    if ((top & 7) != 0) {
+        high = nib - (nib & 8);
+    } else {
+        high = 5;
+    }
+    for (i = 0; i < 7; i++) {
+        out |= ((value >> (i * 4)) & 7) << (i * 4);
+    }
+    return (out & 0xFFFFFFF) | (high << 28);
+}
diff --git a/src/pal/overlays/l00_multiplayer_menu/L00_005666C8.c b/src/pal/overlays/l00_multiplayer_menu/L00_005666C8.c
new file mode 100644
index 000000000..0b2aa3d52
--- /dev/null
+++ b/src/pal/overlays/l00_multiplayer_menu/L00_005666C8.c
@@ -0,0 +1,24 @@
+/* cflags: @ee296 -O2 -G0 */
+#include "common.h"
+
+u32 func_L00_005666C8(s32 value) {
+    u32 out;
+    s32 top;
+    s32 nib;
+    s32 high;
+    s32 i;
+
+    out = 0;
+    top = value >> 28;
+    nib = 0xF;
+    nib = top & nib;
+    if ((top & 7) != 0) {
+        high = nib - (nib & 8);
+    } else {
+        high = 5;
+    }
+    for (i = 0; i < 7; i++) {
+        out |= ((value >> (i * 4)) & 7) << (i * 4);
+    }
+    return (out & 0xFFFFFFF) | (high << 28);
+}
diff --git a/src/pal/overlays/l00_multiplayer_menu/L00_00714AD8.c b/src/pal/overlays/l00_multiplayer_menu/L00_00714AD8.c
deleted file mode 100644
index 0f3a25ba3..000000000
--- a/src/pal/overlays/l00_multiplayer_menu/L00_00714AD8.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "common.h"
-
-extern u8 D_004B7D58[];
-s32 func_L00_00714570();
-s32 func_L00_00714B50();
-
-s64 func_L00_00714AD8(char *arg0, s32 arg1) {
-    func_L00_00714570(arg0);
-    *(s32 *)(arg0 + 88) = (s32)D_004B7D58;
-    func_L00_00714B50(arg0, arg1);
-    return (s32)arg0;
-}
diff --git a/src/pal/overlays/l00_multiplayer_menu/L00_0071F4F8.c b/src/pal/overlays/l00_multiplayer_menu/L00_0071F4F8.c
new file mode 100644
index 000000000..8462d1f9a
--- /dev/null
+++ b/src/pal/overlays/l00_multiplayer_menu/L00_0071F4F8.c
@@ -0,0 +1,41 @@
+#include "common.h"
+
+typedef struct Type2 Type2;
+typedef struct Type3 {
+    char _p0[0x1C];
+    void (*f1C)(Type2 *);
+} Type3;
+
+struct Type2 {
+    char _p0[0x58];
+    Type3 *f58;
+};
+
+typedef struct Type1 {
+    char _p0[0xC];
+    Type2 *fC;
+    char _p10[0xAC - 0x10];
+    s32 fAC;
+    Type2 *fB0[1];
+} Type1;
+
+s32 D_00220D8C = 0;
+u8 D_00220D90 = 0;
+
+void func_00476080(s32 *, f32, f32);
+
+void func_L00_0071F4F8(Type1 *arg0) {
+    s32 i;
+
+    if (arg0->fC != NULL) {
+        arg0->fC->f58->f1C(arg0->fC);
+    }
+    if (D_00220D90 != 0) {
+        func_00476080(&D_00220D8C, 0.0f, 0.0779220834f);
+    } else {
+        func_00476080(&D_00220D8C, 1.0f, 0.0779220834f);
+    }
+    for (i = 0; i < arg0->fAC; i++) {
+        arg0->fB0[i]->f58->f1C(arg0->fB0[i]);
+    }
+}
diff --git a/src/pal/overlays/shared/L00_0062B4F0.c b/src/pal/overlays/shared/L00_0062B4F0.c
new file mode 100644
index 000000000..db55d0a0b
--- /dev/null
+++ b/src/pal/overlays/shared/L00_0062B4F0.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00223248[];
+extern Manager *func_00502150(void);
+extern Allocator *func_00502218(Manager *, s32);
+extern void func_L00_0069F6A8(s32);
+extern s32 func_L00_0069F6B0(void);
+extern s32 func_00500980(void *, u32);
+extern void *func_0015DB90(u32, void *);
+extern Object *func_0050FB98(void *);
+extern s32 func_00501618(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00223248;
+    if (manager->table) {
+        return manager;
+    }
+    return func_00502150();
+}
+
+s32 func_L00_0062B4F0(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_L00_0069F6A8(0x50);
+    size = func_L00_0069F6B0();
+    if (entry != NULL && func_00500980(entry, key) == 0) {
+        allocator = func_00502218(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_0050FB98(func_0015DB90(0x50, block));
+            result = func_00501618(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_00502218(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/pal/overlays/shared/L00_00647FE0.c b/src/pal/overlays/shared/L00_00647FE0.c
new file mode 100644
index 000000000..801269186
--- /dev/null
+++ b/src/pal/overlays/shared/L00_00647FE0.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+typedef struct State {
+    u32 unknown;
+    s32 group;
+} State;
+
+extern s32 func_004A2798(s32 *group, s32 id);
+extern s32 func_00506590(s32 handle, u32 resource);
+extern s32 func_00506000(s32 handle, s32 visible);
+
+void func_L00_00647FE0(State *state, s32 enabled, s32 count)
+{
+    func_00506590(func_004A2798(&state->group, 8), 0x7546);
+    func_00506590(func_004A2798(&state->group, 7), 0x7546);
+    func_00506590(func_004A2798(&state->group, 6), 0x7546);
+    func_00506590(func_004A2798(&state->group, 5), 0x7546);
+    func_00506590(func_004A2798(&state->group, 4), 0x7546);
+
+    func_00506000(func_004A2798(&state->group, 8), 0);
+    func_00506000(func_004A2798(&state->group, 7), 0);
+    func_00506000(func_004A2798(&state->group, 6), 0);
+    func_00506000(func_004A2798(&state->group, 5), 0);
+    func_00506000(func_004A2798(&state->group, 4), 0);
+
+    if (enabled) {
+        switch (count) {
+        case 5:
+            func_00506000(func_004A2798(&state->group, 4), 1);
+        case 4:
+            func_00506000(func_004A2798(&state->group, 5), 1);
+        case 3:
+            func_00506000(func_004A2798(&state->group, 6), 1);
+        case 2:
+            func_00506000(func_004A2798(&state->group, 7), 1);
+        case 1:
+            func_00506000(func_004A2798(&state->group, 8), 1);
+        }
+    }
+}
diff --git a/src/pal/overlays/shared/L00_00650F58.c b/src/pal/overlays/shared/L00_00650F58.c
new file mode 100644
index 000000000..ab8a8a927
--- /dev/null
+++ b/src/pal/overlays/shared/L00_00650F58.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+typedef struct State {
+    u32 unknown;
+    s32 group;
+} State;
+
+extern s32 func_004A2798(s32 *group, s32 id);
+extern s32 func_L00_006A0DB8(s32 handle, u32 resource);
+extern s32 func_00506000(s32 handle, s32 visible);
+
+void func_L00_00650F58(State *state, s32 enabled, s32 count)
+{
+    func_L00_006A0DB8(func_004A2798(&state->group, 8), 0x7546);
+    func_L00_006A0DB8(func_004A2798(&state->group, 7), 0x7546);
+    func_L00_006A0DB8(func_004A2798(&state->group, 6), 0x7546);
+    func_L00_006A0DB8(func_004A2798(&state->group, 5), 0x7546);
+    func_L00_006A0DB8(func_004A2798(&state->group, 4), 0x7546);
+
+    func_00506000(func_004A2798(&state->group, 8), 0);
+    func_00506000(func_004A2798(&state->group, 7), 0);
+    func_00506000(func_004A2798(&state->group, 6), 0);
+    func_00506000(func_004A2798(&state->group, 5), 0);
+    func_00506000(func_004A2798(&state->group, 4), 0);
+
+    if (enabled) {
+        switch (count) {
+        case 5:
+            func_00506000(func_004A2798(&state->group, 4), 1);
+        case 4:
+            func_00506000(func_004A2798(&state->group, 5), 1);
+        case 3:
+            func_00506000(func_004A2798(&state->group, 6), 1);
+        case 2:
+            func_00506000(func_004A2798(&state->group, 7), 1);
+        case 1:
+            func_00506000(func_004A2798(&state->group, 8), 1);
+        }
+    }
+}
diff --git a/src/pal/overlays/shared/L00_006A3E80.c b/src/pal/overlays/shared/L00_006A3E80.c
new file mode 100644
index 000000000..af5016690
--- /dev/null
+++ b/src/pal/overlays/shared/L00_006A3E80.c
@@ -0,0 +1,79 @@
+#include "common.h"
+
+typedef struct Allocator Allocator;
+typedef struct Object Object;
+typedef struct {
+    u32 unknown0[2];
+    void *(*allocate)(Allocator *, s32);
+    void (*release)(Allocator *, void *);
+} AllocatorVtable;
+struct Allocator {
+    AllocatorVtable *vtable;
+};
+typedef struct Manager {
+    void *unknown0;
+    u8 *table;
+} Manager;
+typedef struct {
+    u32 unknown0[2];
+    void (*destroy)(Object *, s32);
+} ObjectVtable;
+struct Object {
+    u32 unknown0[2];
+    ObjectVtable *vtable;
+
+    u8 unknownC[0x50];
+};
+
+extern Manager D_00222138[];
+extern Manager *func_00502150(void);
+extern Allocator *func_00502218(Manager *, s32);
+extern void func_005052C0(s32);
+extern s32 func_005052C8(void);
+extern s32 func_00500980(void *, u32);
+extern void *func_0015DB90(u32, void *);
+extern Object *func_0050EB78(void *);
+extern s32 func_00501618(void *, Object *, u32);
+
+static inline Manager *get_manager(void)
+{
+    Manager *manager = D_00222138;
+    if (manager->table) {
+        return manager;
+    }
+    return func_00502150();
+}
+
+s32 func_L00_006A3E80(u32 key)
+{
+    s32 result = 0;
+    Manager *manager;
+    Allocator *allocator;
+    u8 *state;
+    void *entry;
+    s32 size;
+    void *block;
+    Object *object;
+
+    manager = get_manager();
+    state = (u8 *)manager->table;
+    entry = state != NULL
+                ? *(void **)((u32)state + ((u32) * (s32 *)(state + 0x14) << 2))
+                : NULL;
+    func_005052C0(0x50);
+    size = func_005052C8();
+    if (entry != NULL && func_00500980(entry, key) == 0) {
+        allocator = func_00502218(get_manager(), 1);
+        block = allocator->vtable->allocate(allocator, size);
+        if (block != NULL) {
+            object = func_0050EB78(func_0015DB90(0x50, block));
+            result = func_00501618(entry, object, key) != 0;
+            if (!result) {
+                object->vtable->destroy(object, 2);
+                allocator = func_00502218(get_manager(), 1);
+                allocator->vtable->release(allocator, block);
+            }
+        }
+    }
+    return result;
+}
diff --git a/src/pal/overlays/shared/L00_006BEA78.c b/src/pal/overlays/shared/L00_006BEA78.c
new file mode 100644
index 000000000..e7851471d
--- /dev/null
+++ b/src/pal/overlays/shared/L00_006BEA78.c
@@ -0,0 +1,85 @@
+#include "common.h"
+
+extern s32 func_0045E288();
+extern s32 func_L00_00621580();
+extern s32 func_L00_006B52D0();
+extern s32 func_00516810();
+extern s32 func_L00_006BC8F0();
+extern void func_L00_006BD060();
+extern s32 func_L00_006BE570();
+extern s32 func_00523DF0();
+extern s32 func_0054A308();
+extern s32 D_0021E734;
+extern s32 D_0021DDB4;
+
+#define F(p, T, o) (*(T *)((u8 *)(p) + (o)))
+extern u8 *D_0021E078;
+typedef struct { u8 pad[0xA8]; u8 fA8[0x10]; } Type1;
+extern Type1 D_00171DB8;
+typedef s32 (*Fn1)(u8 *);
+
+void func_L00_006BEA78(u8 *p) {
+    s32 v;
+    u8 *q;
+
+    if (func_00516810(p) || F(p, s32, 0x25CC) == 0x8F) {
+        F(p, u8, 0x2664) = F(p, u8, 0x2666) = 1;
+    }
+    if (func_00516810(p) || (v = F(p, s32, 0x25CC)) == 0x31 || v == 0x98 ||
+        F(p, s32, 0x25D4) == 3 || v == 0x8F || v == 0x12 ||
+        D_0021DDB4 == 1 || D_0021DDB4 == 2) {
+        F(p, u8, 0x2668) = 1;
+        F(p, u8, 0x2663) = 1;
+    } else {
+        F(p, u8, 0x2668) = 0;
+        F(p, u8, 0x2663) = 0;
+    }
+    if (F(p, u8 *, 0x2340) != 0) {
+        F(p, u8 *, 0x2340)[0x23] = F(p, u8 *, 0x2EF0)[0x23];
+    }
+    func_L00_006BC8F0(p);
+    if (F(p, s32, 0x2318) != 1) {
+        if (D_00171DB8.fA8[F(p, s32, 0x2F10)]) {
+            F(p, s32, 0x2300) |= 8;
+        } else if (F(p, s32, 0x2300) & 8) {
+            F(p, s32, 0x2300) &= ~8;
+        }
+        if (D_0021E734 == 1) {
+            if (!D_00171DB8.fA8[F(p, s32, 0x2F10)]) {
+                F(p, s32, 0x2300) |= 0x20;
+            } else if (F(p, s32, 0x2300) & 0x20) {
+                F(p, s32, 0x2300) &= ~0x20;
+            }
+        }
+    }
+    func_L00_006BD060(p, F(p, u8 *, 0x2EF0));
+    if (F(p, u8 *, 0x2EF0)[0x31]) {
+        func_L00_006B52D0(p);
+    }
+    if (D_0021E734 == 1) {
+        if (D_0021E078[0x32] && F(D_0021E078, s8, 0x34) && F(p, s32, 0x2F14) == 1 &&
+            (q = F(p, u8 *, 0x22F0)) != 0) {
+            v = (q[0x23] + F(p, u8 *, 0x2EF0)[0x23]) >> 1;
+            q[0x23] = v;
+            if (F(F(p, u8 *, 0x22F0), s16, 0xBC) == 0x1094) {
+                F(F(F(p, u8 *, 0x22F0), u8 *, 0xAC), u8 *, 0x64)[0x23] = v;
+            }
+        }
+        if (D_0021E734 == 1 && F(D_0021E078, s8, 0x12) && F(p, s32, 0x2EE8) && !F(p, s32, 0x2EF4)) {
+            if (!D_00171DB8.fA8[F(p, s32, 0x2F10)]) {
+                if (F(F(p, u8 *, 0x2F00), s32, 0x1A4) & 2) {
+                    func_00523DF0(p, 0);
+                }
+            } else if (F(F(p, u8 *, 0x2F00), s32, 0x1A4) & 0x20) {
+                func_00523DF0(p, 0);
+            }
+        }
+    }
+    if (F(p, u8, 0x266C) && F(p, s32, 0x2318) == 0xE && F(p, u8, 0x266D)) {
+        func_L00_00621580(F(F(p, u8 *, 0x14), Fn1, 0x4C)(p), 2);
+    }
+    if (func_0054A308(F(p, s32, 0x26E4), 10) || func_0054A308(F(p, s32, 0x26E4), 9)) {
+        func_0045E288(0x3324, 0x76F, 0xBB8, 2);
+    }
+    func_L00_006BE570(p);
+}
diff --git a/src/pal/overlays/shared/L01_0045BF60.c b/src/pal/overlays/shared/L01_0045BF60.c
deleted file mode 100644
index 5d3a632b7..000000000
--- a/src/pal/overlays/shared/L01_0045BF60.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "common.h"
-
-typedef int u128 __attribute__((mode(TI)));
-
-extern s32 func_L01_00429658(u128 *, u128 *, void *, s32, s32 *, s32, u32, f32, f32);
-extern void func_L01_00429818(s32, s32);
-extern void func_L01_00429858(s32, s32);
-extern void func_L01_004425F0(s32, u128, s32, s32, u32, u32, f32, f32, f32);
-
-// Calls func_L01_00429658 with copies of arg1 and arg2, a word set to 0x80000000, 10.0 and the
-// linked byte at +0x28B as a float; when it returns non-zero, calls func_L01_00429818(r, 4),
-// func_L01_00429858(r, 25) and func_L01_004425F0 on the linked word at +0x5F0 with arg1.
-void func_L01_0045BF60(u8 *arg0, u128 arg1, u128 arg2) {
-    u8 *vars = *(u8 **)(arg0 + 0xAC);
-    u128 pos = arg1;
-    u128 dir = arg2;
-    s32 mask = 0x80000000;
-    s32 shot;
-
-    shot = func_L01_00429658(&pos, &dir, arg0, 1, &mask, -1, 0xFFFFFFFF, 10.0f, (f32)vars[0x28B]);
-    if (shot != 0) {
-        func_L01_00429818(shot, 4);
-        func_L01_00429858(shot, 0x19);
-        func_L01_004425F0(*(s32 *)(vars + 0x5F0), pos, 0, -1, 0x84204080, 0x84204080, 0.5f, 1.0f, 1.25f);
-    }
-}
diff --git a/src/pal/overlays/shared/L01_0046A2F0.c b/src/pal/overlays/shared/L01_0046A2F0.c
new file mode 100644
index 000000000..bc727ae55
--- /dev/null
+++ b/src/pal/overlays/shared/L01_0046A2F0.c
@@ -0,0 +1,7 @@
+#include "common.h"
+
+extern void func_L00_00621580(f32, f32);
+
+void func_L01_0046A2F0(f32 x) {
+    func_L00_00621580(0.200000018f, x);
+}
diff --git a/src/pal/overlays/shared/L01_006B8CC0.c b/src/pal/overlays/shared/L01_006B8CC0.c
new file mode 100644
index 000000000..9e66fb7a9
--- /dev/null
+++ b/src/pal/overlays/shared/L01_006B8CC0.c
@@ -0,0 +1,102 @@
+#include "common.h"
+
+typedef struct Type4 {
+    char pad0[0xC];
+    s32 fC;
+} Type4;
+
+typedef struct Type3 {
+    char pad0[0x25CC];
+    s32 f25CC;
+    char pad25D0[0x2EF4 - 0x25D0];
+    s32 f2EF4;
+    s32 f2EF8;
+} Type3;
+
+typedef struct Type2 {
+    char pad0[0x2B8];
+    Type3 *f2B8;
+    Type3 *f2BC;
+    char pad2C0[0x324 - 0x2C0];
+    Type4 *f324;
+    Type3 *f328;
+    Type3 *f32C;
+} Type2;
+
+typedef struct Type1 {
+    char pad0[0x6A];
+    u16 f6A;
+} Type1;
+
+extern s32 D_0021DE3C;
+extern s32 D_0021E824;
+extern s32 D_0021E8A8;
+extern Type3 *D_003660F8[];
+s32 func_L00_005A1078(void);
+Type2 *func_0053E038(Type1 *);
+void func_0053E158(Type2 *, Type3 *);
+void func_0053E580(Type2 *, Type3 *);
+
+s32 func_L01_006B8CC0(Type1 *arg0, s32 arg1, s32 arg2) {
+    s32 i;
+    Type3 *p;
+    Type2 *obj;
+    Type4 *s3;
+    s32 mode;
+
+    if (func_L00_005A1078() || D_0021DE3C) {
+        arg0->f6A = 0;
+        return 0;
+    }
+    p = D_003660F8[0];
+    i = 0;
+    while (i < 10) {
+        if (p && (p->f25CC == 0x71 || p->f25CC == 0x63)) {
+            arg0->f6A = 0;
+            return 0;
+        }
+        i++;
+        p = D_003660F8[i];
+    }
+    if (arg0->f6A < 0x5) {
+        return 0;
+    }
+    obj = func_0053E038(arg0);
+    mode = D_0021E824;
+    if (!obj) {
+        return 0;
+    }
+    s3 = obj->f324;
+    if (mode == 1) {
+        return obj->f2B8 != 0;
+    }
+    if (mode == 0 && D_0021E8A8 == 0 && obj->f2B8) {
+        return 1;
+    }
+    if (mode == 0 && D_0021E8A8 == 1 && obj->f2B8 && (obj->f2BC || !(s3->fC & 0x100000))) {
+        return 1;
+    }
+    p = D_003660F8[0];
+    i = 0;
+    while (i < 10) {
+        if (p && !p->f2EF4 && !p->f2EF8) {
+            if (arg2) {
+                arg2 = 0;
+            } else if (!obj->f2B8) {
+                obj->f328 = p;
+                func_0053E580(obj, p);
+            } else if (!arg1 && !(s3->fC & 0x100000) && !obj->f2BC) {
+                obj->f32C = p;
+                func_0053E158(obj, p);
+            }
+        }
+        i++;
+        p = D_003660F8[i];
+    }
+    if (!obj->f2B8 && !obj->f2BC && !obj->f328 && !obj->f32C) {
+        goto tail;
+    }
+    return 1;
+tail:
+    return arg0->f6A >= 0x5;
+}