diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c index d9d04579e..450d15594 100644 --- a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c +++ b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c @@ -4357,7 +4357,41 @@ void func_8017E578(void *a0) { INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017E5B4); -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017E630); +extern s32 D_80189464; +extern s16 D_80126ADA; +extern s16 D_80126ADE; +extern s16 D_80126AE2; +extern u16 D_80126B5E; +extern u16 D_80126B62; +extern u16 D_80126B66; +extern s32 func_8004787C(s32 a0); +extern s32 func_80047948(s32 a0); +extern void func_8017E8A0(s32 a0, s32 a1); +extern s32 func_8017EC48(s32 a0); + +void func_8017E630(s32 a0) +{ + s32 *s1; + s32 x; + u16 buf[3]; + + x = func_8004787C(*(s16 *)(a0 + 0x22)); + s1 = &D_80189464; + *(s16 *)(a0 + 0x2E) = -x * *s1 / 4096; + x = func_80047948(*(s16 *)(a0 + 0x22)); + *(s16 *)(a0 + 0x32) = -x * *s1 / 4096; + + buf[0] = D_80126B5E; + buf[1] = D_80126B62; + buf[2] = D_80126B66; + func_8017E8A0(a0, (s32)&buf); + + *(s32 *)(a0 + 0x48) = D_80126ADA; + *(s32 *)(a0 + 0x4C) = D_80126ADE; + *(s32 *)(a0 + 0x50) = D_80126AE2; + func_8017EC48(a0); +} + INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017E724); diff --git a/src/ov_SC02_000/ov_SC02_000_jr_8018173C.c b/src/ov_SC02_000/ov_SC02_000_jr_8018173C.c index 359b1cbb4..8d9b517da 100644 --- a/src/ov_SC02_000/ov_SC02_000_jr_8018173C.c +++ b/src/ov_SC02_000/ov_SC02_000_jr_8018173C.c @@ -2834,7 +2834,61 @@ DEFINE_func_80181DE0() /* dedup: shared engine-core @0x80181DE0 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80181DE8); -INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8018173C", func_80181E70); +typedef struct { short m[3][3]; long t[3]; } Mtx_8017DECC; +typedef struct { short vx, vy, vz, pad; } Sv_8017DECC; + +extern s32 func_80012C6C(s32 a0, s32 a1, s32 a2); +extern s32 func_80012ABC(s32, s32, s32); +extern void func_80013F3C(s32 a0); +extern void func_800123F0(s32 a0, s32 a1); +extern void func_80012558(s32 a0, s32 a1); +extern void func_800126C4(s32 a0, s32 a1); +extern void func_8012F14C(s32 a0, s32 a1, s32 a2); + +s32 func_80181E70(s32 param_1, s32 param_2, s32 param_3) +{ + Mtx_8017DECC mtx; + Sv_8017DECC vec; + Sv_8017DECC out; + Sv_8017DECC rot; + + *(s32 *)(param_1 + 8) = (s16)((s16 (*)(s32, s32, s32))func_80012C6C)((s32)*(s16 *)(param_1 + 8), (s32)*(s16 *)(param_1 + 0xc), 4); + *(s32 *)(param_1 + 0x10) = (s16)((s16 (*)(s32, s32, s32))func_80012C6C)((s32)*(s16 *)(param_1 + 0x10), (s32)*(s16 *)(param_1 + 0x14), 4); + *(s16 *)(param_1 + 0x18) = ((s16 (*)(s32, s32, s32))func_80012ABC)((s32)*(s16 *)(param_1 + 0x18), (s32)*(s16 *)(param_1 + 0x20), 4); + *(s16 *)(param_1 + 0x1a) = ((s16 (*)(s32, s32, s32))func_80012ABC)((s32)*(s16 *)(param_1 + 0x1a), (s32)*(s16 *)(param_1 + 0x22), 4); + *(s16 *)(param_1 + 0x1c) = ((s16 (*)(s32, s32, s32))func_80012ABC)((s32)*(s16 *)(param_1 + 0x1c), (s32)*(s16 *)(param_1 + 0x24), 4); + *(s16 *)(param_1 + 0x28) = ((s16 (*)(s32, s32, s32))func_80012C6C)((s32)*(s16 *)(param_1 + 0x28), (s32)*(s16 *)(param_1 + 0x2e), 0x10); + *(s16 *)(param_1 + 0x2a) = ((s16 (*)(s32, s32, s32))func_80012C6C)((s32)*(s16 *)(param_1 + 0x2a), (s32)*(s16 *)(param_1 + 0x30), 0x10); + *(s16 *)(param_1 + 0x2c) = ((s16 (*)(s32, s32, s32))func_80012C6C)((s32)*(s16 *)(param_1 + 0x2c), (s32)*(s16 *)(param_1 + 0x32), 0x10); + + *(s32 *)(param_1 + 0x48) = (s32)*(s16 *)(param_1 + 0x28) + (s32)*(s16 *)(param_3 + 0); + *(s32 *)(param_1 + 0x4c) = (s32)*(s16 *)(param_1 + 0x2a) + (s32)*(s16 *)(param_3 + 2); + *(s32 *)(param_1 + 0x50) = (s32)*(s16 *)(param_1 + 0x2c) + (s32)*(s16 *)(param_3 + 4); + + rot.vx = *(u16 *)(param_1 + 0x18); + rot.vy = *(u16 *)(param_1 + 0x1a) + param_2; + rot.vz = *(u16 *)(param_1 + 0x1c); + + func_80013F3C((s32)&mtx); + func_800123F0((s32)&mtx, (s32)rot.vz); + func_80012558((s32)&mtx, (s32)rot.vy); + func_800126C4((s32)&mtx, (s32)rot.vx); + + mtx.t[0] = (s32)*(s16 *)(param_1 + 0x28) + (s32)*(s16 *)(param_3 + 0); + mtx.t[1] = (s32)*(s16 *)(param_1 + 0x2a) + (s32)*(s16 *)(param_3 + 2); + mtx.t[2] = (s32)*(s16 *)(param_1 + 0x2c) + (s32)*(s16 *)(param_3 + 4); + + vec.vx = 0; + vec.vy = 0; + vec.vz = (s16)*(s32 *)(param_1 + 0x10); + + ((void (*)(s32, s32, s32))func_8012F14C)((s32)&mtx, (s32)&vec, (s32)&out); + + *(s32 *)(param_1 + 0x3c) = (s32)out.vx; + *(s32 *)(param_1 + 0x40) = (s32)out.vy; + *(s32 *)(param_1 + 0x44) = (s32)out.vz; +} + #include "common.h" diff --git a/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c b/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c index 0d1640214..7f84c1458 100644 --- a/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c +++ b/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c @@ -3540,7 +3540,49 @@ INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_801805D INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_801806DC); -INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_80180728); + + +extern s32 func_8012B744(void *a0, void *a1); +extern void func_8012A828(s32, s32); +extern void Square0(s32 *a0, s32 *a1); +extern u8 D_801AFB14[]; + +void func_80180728(s32 param_1) { + LVec1CDC d; + + *(s16 *)(param_1 + 0x2) = 1; + *(s16 *)(param_1 + 0x34) = 0; + *(u16 *)(param_1 + 0x5C) = 0xAA10; + *(s32 *)(param_1 + 0x1C) = (rand() & 0x1F) + 0x28; + + { + void *target = (void *)(param_1 + 0x88); + + d.vx = *(s16 *)(param_1 + 0x6) - *(s16 *)target; + d.vy = 0; + d.vz = *(s16 *)(param_1 + 0xE) - *(s16 *)(param_1 + 0x8C); + Square0(&d.vx, &d.vx); + + if (d.vx + d.vz > 0x8FFFF) { + *(s16 *)(param_1 + 0xFC) = + func_8012B744((void *)(param_1 + 0x4), target); + } else { + register s32 t __asm__("$2") = rand() & 0x3FF; + s32 v1 = t - 0x200; + + if (v1 < 0) { + v1 = t - 0x500; + } else { + v1 = t + 0x100; + } + *(s16 *)(param_1 + 0xFC) = + (*(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + v1) & 0xFFF; + } + } + + ((void (*)(s32, void *))func_8012A828)(param_1, D_801AFB14); +} + INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_80180828); diff --git a/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c b/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c index b0ab4804d..67ada260e 100644 --- a/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c +++ b/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c @@ -3449,7 +3449,41 @@ INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017F01 INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017F064); -INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017F0C4); +extern void func_8012CAE4(void *a0); +extern s32 func_8012C1B8(void); +extern void func_8001C214(s32 a0, s32 a1); +extern void func_8012A828(s32 a0, void *a1); +extern void func_8012E8E0(s32 a0, s32 a1); +extern s16 D_801902A0; +extern s32 D_801835A4; +extern void (*D_8018DC00)(void *); + +void func_8017F0C4(s32 param) { + s32 x; + s32 v1; + + x = func_80029504(); + if (x < 0xF0) { v1 = 0; goto chk; } + if (x < 0xFA) { v1 = 1; goto chk; } + if (x < 0x104) { v1 = 2; goto chk; } + if (x < 0x10E) { v1 = 3; goto chk; } + if (x < 0x118) { v1 = 4; } else { v1 = 5; } +chk: + if (v1 == 0 || v1 == 5) { + func_8012CAE4((void *)param); + return; + } + *(s32 *)(param + 0x20) = func_8012C1B8(); + if (*(s32 *)(param + 0x20) == 0) { + func_8012CAE4((void *)param); + } + func_8001C214(*(s32 *)(param + 0x20), (s32)&D_801902A0); + *(u16 *)(param + 0x2) = 1; + func_8012E8E0(param, (s32)&D_801835A4); + func_8012A828(param, (void *)&D_8018DC00); + *(u16 *)(*(s32 *)(param + 0x68) + 0xC) = 0x7FFF; +} + INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017F1B4); diff --git a/src/ov_SC06_032/ov_SC06_032_jr_80182890.c b/src/ov_SC06_032/ov_SC06_032_jr_80182890.c index 426775e57..9f4e377d3 100644 --- a/src/ov_SC06_032/ov_SC06_032_jr_80182890.c +++ b/src/ov_SC06_032/ov_SC06_032_jr_80182890.c @@ -4624,7 +4624,52 @@ void func_80186160(s32 param_1) } -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80186238); +extern void func_8012CC40(s32 arg0, s32 arg1); +extern void func_80186870(s32 a0); +extern s32 func_8012BEE8(s32 a0); +extern void func_8012C218(void *a0); + +void func_80186238(s32 param_1) +{ + extern s32 D_801BEF44; + s32 iVar; + + switch (*(u16 *)(param_1 + 0x34)) { + case 0: + iVar = ((s32 (*)(s32, s32))func_8012CC40)(param_1, (s32)&D_801BEF44); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + *(u16 *)(param_1 + 0x106); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) + *(u16 *)(param_1 + 0x108); + if (iVar != 0) { + u16 ns = *(u16 *)(param_1 + 0x34) + 1; + *(s32 *)(param_1 + 0x14) = *(s32 *)(param_1 + 0xE0) >> 1; + *(s32 *)(param_1 + 0x18) = 0; + *(s32 *)(param_1 + 0x10) = 0; + *(u16 *)(param_1 + 0x34) = ns; + } + break; + case 1: + iVar = ((s32 (*)(s32, s32))func_8012CC40)(param_1, (s32)&D_801BEF44); + func_80186870(param_1); + if (iVar != 0) { + *(s32 *)(param_1 + 0x1C) = 0x10; + *(u16 *)(param_1 + 0x34) = *(u16 *)(param_1 + 0x34) + 1; + } + break; + case 2: + func_80186870(param_1); + if (func_8012BEE8(param_1) != 0) { + func_8012C218((void *)param_1); + } else if (*(s32 *)(param_1 + 0x1C) & 1) { + *(s32 *)(*(s32 *)(param_1 + 0x20) + 4) |= 0x80000000; + } else { + *(s32 *)(*(s32 *)(param_1 + 0x20) + 4) &= 0x7FFFFFFF; + } + break; + } +} + #include "common.h" @@ -7147,7 +7192,37 @@ void func_8018B184(void *a0) } -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018B1A4); +void func_8018B1A4(int param_1) { + + extern u8 D_801C2D30[]; + extern u8 D_801C7C68[]; + extern u8 D_801CA2A8[]; + extern u8 D_801C2D64[]; + int iVar1; + + iVar1 = func_8012C354(param_1, D_801C2D30); + if (iVar1 != 0) { + if (*(short *)(param_1 + 0x70) != 0) { + func_8001C214(*(int *)(param_1 + 0x20), D_801C7C68); + } + *(u8 *)(param_1 + 0xc0) = 1; + *(s32 *)(param_1 + 0xb4) = 0xffffdfdf; + func_8012B030(param_1); + *(s16 *)(param_1 + 0xae) = 0x2100; + func_8012A828(param_1, D_801CA2A8); + *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1; + func_8012B23C(param_1); + *(u32 *)(param_1 + 0xbc) = (u32)D_801C2D64; + *(u32 *)(param_1 + 0xc4) = *(u32 *)(param_1 + 0xc4) | 2; + *(u16 *)(*(int *)(param_1 + 0x20) + 0x2c) = + *(u16 *)(*(int *)(param_1 + 0x20) + 0x2c) | 0x10; + *(short *)(*(int *)(param_1 + 0x20) + 0x18) = 0x2400; + *(short *)(*(int *)(param_1 + 0x20) + 0x1a) = 0x2400; + *(short *)(*(int *)(param_1 + 0x20) + 0x1c) = 0x2400; + } + return; +} + void func_8018B294(void) { } 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 c11def849..ad11cfe53 100644 --- a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c +++ b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c @@ -4035,7 +4035,37 @@ void func_80180440(s32 arg0) { } -INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180490); +extern s32 *D_80186800[]; +extern s32 *D_80186810[]; + +void func_80180490(void *a0) { + s32 ret; + s16 idx; + s32 *p0, *p1; + + ret = func_8012C1B8(); + *(s32 *)((u8 *)a0 + 0x20) = ret; + if (ret == 0) { + func_8012CAE4(a0); + return; + } + + *(u16 *)((u8 *)a0 + 0xFE) = (*(u16 *)((u8 *)a0 + 0x70) >> 8) & 7; + *(u16 *)((u8 *)a0 + 0x70) = *(u16 *)((u8 *)a0 + 0x70) & 0xF; + idx = *(s16 *)((u8 *)a0 + 0xFE); + p0 = D_80186800[idx]; + p1 = D_80186810[idx]; + p1[*(s16 *)((u8 *)a0 + 0x70) * 2] = p0[*(s16 *)((u8 *)a0 + 0x70)]; + p1[*(s16 *)((u8 *)a0 + 0x70) * 2 + 1] = 0; + func_8001C214(*(s32 *)((u8 *)a0 + 0x20), &p1[*(s16 *)((u8 *)a0 + 0x70) * 2]); + + *(u16 *)((u8 *)a0 + 0x106) = rand() & 0xF0; + *(u16 *)((u8 *)a0 + 0x108) = rand() & 0xF0; + func_8012B23C(a0); + *(s32 *)((u8 *)a0 + 0x1C) = 0x20; + func_8012AD50(a0); +} + extern void (*D_80186840[])(void); diff --git a/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c b/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c index e0071fbee..c28d1ef03 100644 --- a/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c +++ b/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c @@ -3877,7 +3877,80 @@ void func_8017D4E4(s32 param_1, s16 *param_2) { } -INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_8017D67C); +typedef struct { s16 x; s16 y; s16 z; s16 pad; } SVec8017D67C; +typedef struct { SVec8017D67C v[2]; s32 col[2]; s32 tag; s32 pad; } Prim8017D67C; + +extern void func_8012C218(void *a0); +extern void func_8012EC04(s32 param_1, s32 param_2, s32 *param_3); +extern void func_8012F14C(s32 a0, s32 a1, s32 a2); +extern void func_8012CC40(s32 a0, s32 a1); +extern s32 func_80016A5C(); + +void func_8017D67C(s32 arg0) { + u16 out[4]; + s32 buf[8]; + Prim8017D67C prim; + s32 e; + u16 st; + s32 p; + + e = arg0; + if (*(s16 *)(e + 0xA) >= 0x10) { + func_8012C218((void *)e); + return; + } + + switch (*(u16 *)(e + 0x34)) { + case 0: + p = *(s32 *)(e + 0x64); + if (*(u16 *)p != 0) { + func_8012EC04(p, *(s16 *)(e + 0xFC), buf); + func_8012F14C((s32)buf, *(s32 *)(e + 0xDC), (s32)out); + *(u16 *)(e + 0x6) = out[0]; + *(u16 *)(e + 0xA) = out[1]; + *(u16 *)(e + 0xE) = out[2]; + } + *(s32 *)(e + 0xE4) += *(s32 *)(e + 0xE8); + if (*(s32 *)(e + 0xE4) >= *(s32 *)(e + 0xE0)) { + *(s32 *)(e + 0xE4) = *(s32 *)(e + 0xE0); + *(u16 *)(e + 0x34) += 1; + } + break; + case 1: + out[2] = 0; + out[0] = 0; + out[1] = *(s32 *)(e + 0xE4); + if (((s32 (*)(s32, u16 *))func_8012CC40)(e, out) & 0x2000) { + *(u16 *)(e + 0x34) += 1; + } + break; + case 2: + *(s32 *)(e + 0xEC) += 0x10; + if (*(s32 *)(e + 0xEC) >= *(s32 *)(e + 0xE4)) { + func_8012C218((void *)e); + return; + } + break; + } + + prim.v[1].z = 0; + prim.v[1].x = 0; + prim.v[0].z = 0; + prim.v[0].x = 0; + prim.tag = 0x50000000; + st = *(u16 *)(e + 0x34); + prim.col[0] = 0x808080; + prim.col[1] = 0x101010; + if (st < 2) { + prim.v[0].y = *(s32 *)(e + 0xE4); + prim.v[1].y = 0; + } else { + prim.v[0].y = *(s32 *)(e + 0xE4); + prim.v[1].y = *(s32 *)(e + 0xEC); + } + func_80016A5C(&prim, *(s32 *)(e + 0x20) + 0x34); +} + @@ -4363,7 +4436,28 @@ void func_8018163C(s32 t) INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80181924); -INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80181C74); +extern u8 D_801BFCCC; +extern u16 D_8018E33C; +extern void func_8017D8A4(s32 a0, void *a1, void *a2, s32 a3, s32 a4); + +void func_80181C74(s32 a0, s32 a1) { + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x00, (u8 *)&D_8018E33C + 0x00, (u8 *)&D_8018E33C + 0x6C, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x0C, (u8 *)&D_8018E33C + 0x0C, (u8 *)&D_8018E33C + 0x78, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x18, (u8 *)&D_8018E33C + 0x18, (u8 *)&D_8018E33C + 0x84, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x24, (u8 *)&D_8018E33C + 0x24, (u8 *)&D_8018E33C + 0x90, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x30, (u8 *)&D_8018E33C + 0x30, (u8 *)&D_8018E33C + 0x9C, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x60, (u8 *)&D_8018E33C + 0x3C, (u8 *)&D_8018E33C + 0xA8, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x6C, (u8 *)&D_8018E33C + 0x48, (u8 *)&D_8018E33C + 0xB4, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x78, (u8 *)&D_8018E33C + 0x54, (u8 *)&D_8018E33C + 0xC0, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0xA8, (u8 *)&D_8018E33C + 0x60, (u8 *)&D_8018E33C + 0xCC, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x3C, (u8 *)&D_8018E33C - 0x90, (u8 *)&D_8018E33C + 0xD8, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x48, (u8 *)&D_8018E33C - 0x84, (u8 *)&D_8018E33C + 0xE4, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x54, (u8 *)&D_8018E33C - 0x78, (u8 *)&D_8018E33C + 0xF0, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x84, (u8 *)&D_8018E33C - 0x30, (u8 *)&D_8018E33C + 0xFC, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x90, (u8 *)&D_8018E33C - 0x24, (u8 *)&D_8018E33C + 0x108, a1, 1); + func_8017D8A4(*(s32 *)&D_801BFCCC + 0x9C, (u8 *)&D_8018E33C - 0x18, (u8 *)&D_8018E33C + 0x114, a1, 1); +} + INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80181E64);