diff --git a/src/md_MAIN_003/md_MAIN_003_jr_800D1E18.c b/src/md_MAIN_003/md_MAIN_003_jr_800D1E18.c
index 38cb3573e..a4785a1fa 100644
--- a/src/md_MAIN_003/md_MAIN_003_jr_800D1E18.c
+++ b/src/md_MAIN_003/md_MAIN_003_jr_800D1E18.c
@@ -346,7 +346,79 @@ void func_800D2454(s32 a0, s32 a1, s32 *a2) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_003/nonmatchings/md_MAIN_003_jr_800D1E18", func_800D24D0);
+#include "common.h"
+extern s32 D_800EC9DC;
+extern s32 D_800A5F1C;
+extern void StCdInterrupt(void);
+extern s32 D_800EC9B0[];
+extern s32 D_800EC9A4[];
+extern s32 D_800EC9B8;
+extern s16 D_800EC9BC[];
+extern s16 D_800EC9BE[];
+extern s16 D_800EC9C0[];
+extern s32 D_800EC9CC;
+extern s16 D_800EC9D0;
+extern s16 D_800EC9D2;
+extern s16 D_800EC9D4;
+extern s16 D_800EC9D6;
+extern s32 D_800EC9D8;
+extern s32 D_800EC9F0;
+extern u16 aD_800EC9BC[] __asm__("D_800EC9BC");
+extern void func_800D2C88();
+extern void func_800599B8(u16 *, u16 *);
+typedef struct { u16 x, y, w, h; } D24D0_Rect;
+
+void func_800D24D0(void) {
+    D24D0_Rect sp10[2];
+    s32 s0;
+    s32 idx;
+    s32 r;
+    s16 *p;
+    s32 n;
+
+    if (D_800EC9DC != 0) {
+        if (D_800A5F1C != 0) {
+            StCdInterrupt();
+            D_800A5F1C = 0;
+        }
+    }
+    sp10[0] = *(D24D0_Rect *)&D_800EC9D0;
+    {
+        s32 *pb = &D_800EC9B8;
+        s0 = *pb;
+        __asm__ __volatile__("" ::: "memory");
+        *pb = (*pb == 0);
+    }
+    if (D_800EC9F0 != 0) {
+        r = D_800EC9C0[D_800EC9CC * 4] % D_800EC9D4;
+        if (r != 0) {
+            D_800EC9F0 = 0;
+            D_800EC9D0 = D_800EC9D0 + r;
+            goto join;
+        }
+    }
+    {
+        s16 *px = &D_800EC9D0;
+        *px = *px + D_800EC9D4;
+    }
+join:
+    p = (s16 *)((u8 *)D_800EC9A4 + 0x2C);
+    idx = D_800EC9CC;
+    if (*p < D_800EC9BC[idx * 4] + D_800EC9C0[idx * 4]) {
+        __asm__ __volatile__("");
+        ((void (*)()) func_800D2C88)((&D_800EC9A4[3])[D_800EC9B8],
+                                    ((D_800EC9D4 << 4) * ((D_800EC9D6 - 1) / 16 + 1)) >> 1);
+    } else {
+        D_800EC9D8 = 1;
+        n = (idx == 0);
+        D_800EC9CC = n;
+        *p = *(u16 *)((u8 *)aD_800EC9BC + n * 8);
+        D_800EC9F0 = 1;
+        D_800EC9D2 = D_800EC9BE[n * 4];
+    }
+    func_800599B8((u16 *)sp10, (u16 *)D_800EC9B0[s0]);
+}
+
 
 extern s32 func_800D27A0();
 extern void func_800D3234(s32 a0, s32 a1);
diff --git a/src/md_MAIN_028/md_MAIN_028.c b/src/md_MAIN_028/md_MAIN_028.c
index 5f1ccdf35..d04ceb977 100644
--- a/src/md_MAIN_028/md_MAIN_028.c
+++ b/src/md_MAIN_028/md_MAIN_028.c
@@ -302,7 +302,86 @@ s32 func_800CB6D4(s32 a0) {
 }
 
 
-INCLUDE_ASM("asm/md_MAIN_028/nonmatchings/md_MAIN_028", func_800CB8A0);
+void func_800CB8A0(void *a0) {
+    extern s32 func_80017DC4(void *a0, void *a1);
+    extern void func_8012F14C(s32 a0, s32 a1, s32 a2);
+    extern void func_800D20C0(void *a0, void *a1, s32 a2);
+    extern void func_800D23D0(void *a0);
+    extern void func_80017E68(void *a0, void *a1);
+    extern void RotMatrixYXZ(void *a0, void *a1);
+    extern void func_80048D9C(void *a0, void *a1);
+    extern s32 func_80017758(void *a0, void *a1);
+    extern u8 D_800CBECC[];
+
+    s16 vecA[4];
+    s16 rot[4];
+    u8 info[0x38];
+    u8 s2vec[0x20];
+    s16 mtx[16];
+    u16 fld;
+    u16 fld2;
+    s16 ang;
+    u8 *tbl;
+    s8 last;
+    s16 i;
+
+    fld = *(u16 *)((s32)a0 + 0x28);
+    vecA[2] = fld;
+    vecA[1] = fld;
+    vecA[0] = fld;
+    func_80017DC4(vecA, s2vec);
+
+    vecA[2] = 0;
+    vecA[0] = 0;
+    vecA[1] = -0x2C;
+    func_8012F14C((s32)a0 + 0x38, (s32)vecA, (s32)vecA);
+
+    func_800D20C0(vecA, rot, 5);
+    func_800D23D0(rot);
+
+    *(s16 *)(info + 0x0C) = 0;
+    *(s16 *)(info + 0x0A) = 0;
+    *(s16 *)(info + 0x08) = 0;
+    *(s16 *)(info + 0x1C) = 0;
+    *(s16 *)(info + 0x14) = 0;
+    *(s16 *)(info + 0x04) = 0;
+
+    fld2 = *(u16 *)((s32)a0 + 0x28);
+
+    *(u8 *)(info + 0x26) = 0;
+    *(u8 *)(info + 0x22) = 0;
+    *(u8 *)(info + 0x21) = 0;
+    *(u8 *)(info + 0x20) = 0;
+    *(u8 *)(info + 0x2A) = 0;
+    *(u8 *)(info + 0x29) = 0;
+    *(u8 *)(info + 0x28) = 0;
+    *(u8 *)(info + 0x2E) = 0;
+    *(u8 *)(info + 0x2D) = 0;
+    *(u8 *)(info + 0x2C) = 0;
+    *(u32 *)(info + 0x30) = 0x50000000;
+
+    ang = (s16)fld2 >> 6;
+    ang = ang + 0x60;
+    *(s8 *)(info + 0x25) = (s8)ang;
+    *(s8 *)(info + 0x24) = (s8)ang;
+    func_80017E68(vecA, s2vec);
+
+    RotMatrixYXZ(rot, mtx);
+    func_80048D9C(s2vec, mtx);
+
+    tbl = D_800CBECC;
+    for (i = 0; i < 4; i++) {
+        *(s16 *)(info + 0x00) = (s8)*tbl; tbl++;
+        *(s16 *)(info + 0x02) = (s8)*tbl; tbl++;
+        *(s16 *)(info + 0x10) = (s8)*tbl; tbl++;
+        *(s16 *)(info + 0x12) = (s8)*tbl; tbl++;
+        *(s16 *)(info + 0x18) = (s8)*tbl; tbl++;
+        last = (s8)*tbl; tbl--;
+        *(s16 *)(info + 0x1A) = last;
+        func_80017758(info, s2vec);
+    }
+}
+
 
 extern u8 D_80078EC1;
 extern void (*D_800CBEE0[])();
@@ -321,7 +400,7 @@ void func_800CBA74(int param_1)
 typedef struct { s32 w[4]; } Blk_800CBAD0;
 
 void func_800CBAD0(s32 a0) {
-    extern void func_800CB8A0(s32 a0);
+    extern void func_800CB8A0();
 
     s32 s;
     s32 v;
@@ -349,7 +428,7 @@ L_inc:
 
 void func_800CBBA0(void *a0) {
     typedef struct { s32 w[4]; } S16;
-    extern void func_800CB8A0(s32 a0);
+    extern void func_800CB8A0();
     s32 a1;
     s32 n;
     s32 m;
@@ -428,7 +507,7 @@ void func_800CBD78(s32 param_1) {
 
 typedef struct { s32 w[4]; } Struct16;
 
-extern void func_800CB8A0(s32 a0);
+extern void func_800CB8A0();
 extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6);
 
 void func_800CBDD0(s32 a0) {
diff --git a/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c b/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c
index 01ea3c231..5602e5546 100644
--- a/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c
+++ b/src/ov_SC01_006/ov_SC01_006_jr_8017ED5C.c
@@ -3088,7 +3088,58 @@ L874:
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_8017F9F8);
+
+extern B16 D_800A5E88, D_800A5E98, D_800A5EA8;
+extern B16 D_801CE030, D_801CE040, D_801CE050;
+
+s32 func_8017F9F8(s32 a0in) {
+    extern s32 func_8017D9A0(void *);
+    extern void func_8013C964(void);
+    extern s32 func_800291B4(s32);
+    extern s32 func_8001AAA0();
+    extern s32 func_8001B710();
+    extern void func_80028620(s32, void *);
+    register s32 a0 __asm__("$18");
+    B16 *d;
+
+    a0 = a0in;
+    *(s16 *)(*(s32 *)(a0 + 0xD4) + 0xFC) = 0;
+    if (*(s16 *)(a0 + 0xFE) == 0 && func_8017D9A0((void *)a0) != 0) {
+        *(s16 *)(a0 + 0xFE) = 1;
+    }
+    if (*(s16 *)(a0 + 0x10A) >= 0x31) {
+        u16 n = *(u16 *)(a0 + 0x106) + 0x10;
+        *(s16 *)(a0 + 0x106) = n;
+        *(s16 *)(a0 + 0x108) = n;
+        if ((s16)n >= 0x100) {
+            *(s16 *)(a0 + 0x106) = 0xFF;
+            *(s16 *)(a0 + 0x108) = 0xFF;
+        }
+        *(s16 *)(a0 + 0x10A) -= 3;
+        return 0;
+    }
+    if (*(s16 *)(a0 + 0xFE) == 0) {
+        return 0;
+    }
+    func_8013C964();
+    d = &D_800A5E88;
+    *(s16 *)(*(s32 *)(a0 + 0xD4) + 0x108) = 2;
+    d[0] = D_801CE030;
+    d[1] = D_801CE040;
+    d[2] = D_801CE050;
+    func_80028620(0, d);
+    func_80028620(1, d + 1);
+    func_80028620(2, d + 2);
+    if (*(s16 *)(a0 + 0x100) != 0x1C) {
+        return 1;
+    }
+    if (func_800291B4(0x7E) & 0x20) {
+        ((s32 (*)(s32))func_8001AAA0)(0x3D);
+        func_8001B710();
+    }
+    return 1;
+}
+
 
 INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8017ED5C", func_8017FBCC);
 
diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
index c76ac6838..e2df119f1 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c
@@ -4774,7 +4774,62 @@ void func_8017F59C(void *a0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F69C);
+extern s16 D_801D0B7C;
+extern void func_8017F888();
+extern u8 D_80186584[];
+extern void func_8012AD80();
+extern s32 func_8012BEE8();
+extern void func_8012B200(u8 *a0);
+extern s32 func_80132EF4();
+extern void func_8012A828();
+extern void func_8012AD44();
+extern void func_8002D4C8(s32 a0, s32 a1);
+extern u8 D_801CCFA8[];
+
+void func_8017F69C(s32 s0) {
+    s32 v0;
+    register s32 obj;
+    register s32 y;
+
+    switch (*(u16 *)(s0 + 0x34)) {
+    case 0:
+        func_8012AD80(s0);
+        if (func_8012BEE8(s0) == 0) {
+            return;
+        }
+        func_8012B200((u8 *)s0);
+        goto inc;
+    case 1:
+        if ((u16)D_801D0B7C != 7) {
+            return;
+        }
+        func_8017F888((s32 *)s0, (s32 *)&D_80186584);
+    inc:
+        v0 = *(u16 *)(s0 + 0x34);
+        *(u16 *)(s0 + 0x34) = v0 + 1;
+        break;
+    case 2:
+        if ((u16)D_801D0B7C != 6) {
+            return;
+        }
+        *(s32 *)(s0 + 0x10) = (*(s32 *)(*(s32 *)(s0 + 0x64) + 4) - *(s32 *)(s0 + 4)) >> 4;
+        y = *(s32 *)(s0 + 8) + 0x1400000;
+        *(s32 *)(s0 + 0x14) = (*(s32 *)(*(s32 *)(s0 + 0x64) + 8) - y) >> 4;
+        *(s32 *)(s0 + 0x18) = (*(s32 *)(*(s32 *)(s0 + 0x64) + 0xC) - *(s32 *)(s0 + 0xC) + 0x200000) >> 4;
+        *(s32 *)(s0 + 0x1C) = 0x10;
+        obj = func_80132EF4(s0, 0x77);
+        if (obj != 0) {
+            *(s32 *)(obj + 4) += *(s32 *)(s0 + 0x10) * 4;
+            *(s32 *)(obj + 8) += -0x300000 + (*(s32 *)(s0 + 0x14) * 4);
+            *(s32 *)(obj + 0xC) += *(s32 *)(s0 + 0x18) * 4;
+        }
+        func_8012A828(s0, D_801CCFA8);
+        func_8012AD44((s32 *)s0, 3);
+        func_8002D4C8(0xC1A, 0);
+        return;
+    }
+}
+
 
 
 extern void (*D_8018658C[])(void);
diff --git a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
index 2cd51ada4..6eb459446 100644
--- a/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
+++ b/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.c
@@ -4970,7 +4970,55 @@ void func_8017FBD0(s32 s0) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8017C8D0", func_8017FCA8);
+void func_8017FCA8(s32 a0)
+{
+    typedef struct { s16 m0, m1, m2, m3; } PosFCA8;
+    extern s16 D_80126940[4];
+    extern s32 func_8012E544(s32 a0);
+    extern void func_80015978(s32 a0, s32 *a1);
+    extern s32 func_80013294(void *a0, void *a1);
+    extern s32 ratan2(s32 dx, s32 dy);
+    extern void func_80181394();
+
+    PosFCA8 cur;
+    PosFCA8 target;
+    s32 ret;
+    s32 dist;
+    s16 clamped;
+    register s16 va __asm__("$6");
+    register s16 vb __asm__("$5");
+    register s32 sc __asm__("$2");
+
+    cur = *(PosFCA8 *) D_80126940;
+    ret = func_8012E544(0x306);
+    if (ret != 0) {
+        func_80015978(ret + 4, (s32 *) &target);
+        if (cur.m1 > -0x200) {
+            cur.m1 = -0x200;
+        }
+        func_80015978(ret + 4, (s32 *) &target);
+        target.m1 = cur.m1;
+        dist = func_80013294(&cur, &target) - 0x100;
+        clamped = dist;
+        if (clamped < 0) {
+            clamped = 0;
+        }
+        if (clamped > 0x300) {
+            clamped = 0x300;
+        }
+        va = ((clamped * 512) / 0x300) + 0x38;
+        *(s16 *) (a0 + 0x20) = va;
+        vb = ((clamped * 111) / 0x300) - 0x70;
+        *(s16 *) (a0 + 0x30) = vb;
+        sc = ((clamped * 800) / 0x300) + 0x190;
+        *(s32 *) (a0 + 0x14) = (s16) sc;
+    } else {
+        target = *(PosFCA8 *) D_80126940;
+    }
+
+    func_80181394(a0, &cur, ratan2(cur.m0 - target.m0, cur.m2 - target.m2) & 0xfff);
+}
+
 
 extern s32 func_80029504(void);
 extern void func_8017FEC4(s32 a0);