diff --git a/src/ov_SC01_000/ov_SC01_000_jr_8015AE2C.c b/src/ov_SC01_000/ov_SC01_000_jr_8015AE2C.c index b06f87a9c..ec99fe1b5 100644 --- a/src/ov_SC01_000/ov_SC01_000_jr_8015AE2C.c +++ b/src/ov_SC01_000/ov_SC01_000_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018183C[]; + extern u32 D_8018185C, D_80181860, D_80181864, D_80181868; + extern u32 D_8018185C, D_80181860, D_80181864, D_80181868; + extern u32 D_8018185C, D_80181860, D_80181864, D_80181868; + extern u32 D_8018185C, D_80181860, D_80181864, D_80181868; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018183C[0x00], p); + ApplyMatrixSV(mat, &D_8018183C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018183C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018183C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181864; + *(u32 *)(prim + 0x24) = D_8018185C; + *(u32 *)(prim + 0x28) = D_80181868; + *(u32 *)(prim + 0x2c) = D_80181860; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC01_001/ov_SC01_001_jr_8015AE2C.c b/src/ov_SC01_001/ov_SC01_001_jr_8015AE2C.c index 8684e408e..21bd102ca 100644 --- a/src/ov_SC01_001/ov_SC01_001_jr_8015AE2C.c +++ b/src/ov_SC01_001/ov_SC01_001_jr_8015AE2C.c @@ -4482,7 +4482,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018648C[]; + extern u32 D_801864AC, D_801864B0, D_801864B4, D_801864B8; + extern u32 D_801864AC, D_801864B0, D_801864B4, D_801864B8; + extern u32 D_801864AC, D_801864B0, D_801864B4, D_801864B8; + extern u32 D_801864AC, D_801864B0, D_801864B4, D_801864B8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018648C[0x00], p); + ApplyMatrixSV(mat, &D_8018648C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018648C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018648C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801864B4; + *(u32 *)(prim + 0x24) = D_801864AC; + *(u32 *)(prim + 0x28) = D_801864B8; + *(u32 *)(prim + 0x2c) = D_801864B0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC01_004/ov_SC01_004_jr_8015AE2C.c b/src/ov_SC01_004/ov_SC01_004_jr_8015AE2C.c index fb108ae71..3cdab1a08 100644 --- a/src/ov_SC01_004/ov_SC01_004_jr_8015AE2C.c +++ b/src/ov_SC01_004/ov_SC01_004_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_004/nonmatchings/ov_SC01_004_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181E50[]; + extern u32 D_80181E70, D_80181E74, D_80181E78, D_80181E7C; + extern u32 D_80181E70, D_80181E74, D_80181E78, D_80181E7C; + extern u32 D_80181E70, D_80181E74, D_80181E78, D_80181E7C; + extern u32 D_80181E70, D_80181E74, D_80181E78, D_80181E7C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181E50[0x00], p); + ApplyMatrixSV(mat, &D_80181E50[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181E50[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181E50[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181E78; + *(u32 *)(prim + 0x24) = D_80181E70; + *(u32 *)(prim + 0x28) = D_80181E7C; + *(u32 *)(prim + 0x2c) = D_80181E74; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC01_005/ov_SC01_005_jr_8015AE2C.c b/src/ov_SC01_005/ov_SC01_005_jr_8015AE2C.c index 2bea7cbbb..db767c95d 100644 --- a/src/ov_SC01_005/ov_SC01_005_jr_8015AE2C.c +++ b/src/ov_SC01_005/ov_SC01_005_jr_8015AE2C.c @@ -4485,7 +4485,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80184FE4[]; + extern u32 D_80185004, D_80185008, D_8018500C, D_80185010; + extern u32 D_80185004, D_80185008, D_8018500C, D_80185010; + extern u32 D_80185004, D_80185008, D_8018500C, D_80185010; + extern u32 D_80185004, D_80185008, D_8018500C, D_80185010; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80184FE4[0x00], p); + ApplyMatrixSV(mat, &D_80184FE4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80184FE4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80184FE4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018500C; + *(u32 *)(prim + 0x24) = D_80185004; + *(u32 *)(prim + 0x28) = D_80185010; + *(u32 *)(prim + 0x2c) = D_80185008; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC01_006/ov_SC01_006_jr_8015AE2C.c b/src/ov_SC01_006/ov_SC01_006_jr_8015AE2C.c index ef483b1c3..2521335fc 100644 --- a/src/ov_SC01_006/ov_SC01_006_jr_8015AE2C.c +++ b/src/ov_SC01_006/ov_SC01_006_jr_8015AE2C.c @@ -4485,7 +4485,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80184FE4[]; + extern u32 D_80185004, D_80185008, D_8018500C, D_80185010; + extern u32 D_80185004, D_80185008, D_8018500C, D_80185010; + extern u32 D_80185004, D_80185008, D_8018500C, D_80185010; + extern u32 D_80185004, D_80185008, D_8018500C, D_80185010; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80184FE4[0x00], p); + ApplyMatrixSV(mat, &D_80184FE4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80184FE4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80184FE4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018500C; + *(u32 *)(prim + 0x24) = D_80185004; + *(u32 *)(prim + 0x28) = D_80185010; + *(u32 *)(prim + 0x2c) = D_80185008; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC01_008/ov_SC01_008_jr_8015AE2C.c b/src/ov_SC01_008/ov_SC01_008_jr_8015AE2C.c index 16e3c183a..1b16960bc 100644 --- a/src/ov_SC01_008/ov_SC01_008_jr_8015AE2C.c +++ b/src/ov_SC01_008/ov_SC01_008_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_008/nonmatchings/ov_SC01_008_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801823C4[]; + extern u32 D_801823E4, D_801823E8, D_801823EC, D_801823F0; + extern u32 D_801823E4, D_801823E8, D_801823EC, D_801823F0; + extern u32 D_801823E4, D_801823E8, D_801823EC, D_801823F0; + extern u32 D_801823E4, D_801823E8, D_801823EC, D_801823F0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801823C4[0x00], p); + ApplyMatrixSV(mat, &D_801823C4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801823C4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801823C4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801823EC; + *(u32 *)(prim + 0x24) = D_801823E4; + *(u32 *)(prim + 0x28) = D_801823F0; + *(u32 *)(prim + 0x2c) = D_801823E8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC01_009/ov_SC01_009_jr_8015AE2C.c b/src/ov_SC01_009/ov_SC01_009_jr_8015AE2C.c index 7bc5c1fdb..91cdb8e94 100644 --- a/src/ov_SC01_009/ov_SC01_009_jr_8015AE2C.c +++ b/src/ov_SC01_009/ov_SC01_009_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801855AC[]; + extern u32 D_801855CC, D_801855D0, D_801855D4, D_801855D8; + extern u32 D_801855CC, D_801855D0, D_801855D4, D_801855D8; + extern u32 D_801855CC, D_801855D0, D_801855D4, D_801855D8; + extern u32 D_801855CC, D_801855D0, D_801855D4, D_801855D8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801855AC[0x00], p); + ApplyMatrixSV(mat, &D_801855AC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801855AC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801855AC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801855D4; + *(u32 *)(prim + 0x24) = D_801855CC; + *(u32 *)(prim + 0x28) = D_801855D8; + *(u32 *)(prim + 0x2c) = D_801855D0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC01_074/ov_SC01_074_jr_8015AE2C.c b/src/ov_SC01_074/ov_SC01_074_jr_8015AE2C.c index 34af5cda0..f87f1c904 100644 --- a/src/ov_SC01_074/ov_SC01_074_jr_8015AE2C.c +++ b/src/ov_SC01_074/ov_SC01_074_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018122C[]; + extern u32 D_8018124C, D_80181250, D_80181254, D_80181258; + extern u32 D_8018124C, D_80181250, D_80181254, D_80181258; + extern u32 D_8018124C, D_80181250, D_80181254, D_80181258; + extern u32 D_8018124C, D_80181250, D_80181254, D_80181258; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018122C[0x00], p); + ApplyMatrixSV(mat, &D_8018122C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018122C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018122C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181254; + *(u32 *)(prim + 0x24) = D_8018124C; + *(u32 *)(prim + 0x28) = D_80181258; + *(u32 *)(prim + 0x2c) = D_80181250; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8015AE2C.c b/src/ov_SC01_080/ov_SC01_080_jr_8015AE2C.c index 7f77c0042..074206add 100644 --- a/src/ov_SC01_080/ov_SC01_080_jr_8015AE2C.c +++ b/src/ov_SC01_080/ov_SC01_080_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018618C[]; + extern u32 D_801861AC, D_801861B0, D_801861B4, D_801861B8; + extern u32 D_801861AC, D_801861B0, D_801861B4, D_801861B8; + extern u32 D_801861AC, D_801861B0, D_801861B4, D_801861B8; + extern u32 D_801861AC, D_801861B0, D_801861B4, D_801861B8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018618C[0x00], p); + ApplyMatrixSV(mat, &D_8018618C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018618C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018618C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801861B4; + *(u32 *)(prim + 0x24) = D_801861AC; + *(u32 *)(prim + 0x28) = D_801861B8; + *(u32 *)(prim + 0x2c) = D_801861B0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC01_084/ov_SC01_084_jr_8015AE2C.c b/src/ov_SC01_084/ov_SC01_084_jr_8015AE2C.c index 930a0a902..7b5c0c80e 100644 --- a/src/ov_SC01_084/ov_SC01_084_jr_8015AE2C.c +++ b/src/ov_SC01_084/ov_SC01_084_jr_8015AE2C.c @@ -4483,7 +4483,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80189480[]; + extern u32 D_801894A0, D_801894A4, D_801894A8, D_801894AC; + extern u32 D_801894A0, D_801894A4, D_801894A8, D_801894AC; + extern u32 D_801894A0, D_801894A4, D_801894A8, D_801894AC; + extern u32 D_801894A0, D_801894A4, D_801894A8, D_801894AC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80189480[0x00], p); + ApplyMatrixSV(mat, &D_80189480[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80189480[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80189480[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801894A8; + *(u32 *)(prim + 0x24) = D_801894A0; + *(u32 *)(prim + 0x28) = D_801894AC; + *(u32 *)(prim + 0x2c) = D_801894A4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_000/ov_SC02_000_jr_8015AE2C.c b/src/ov_SC02_000/ov_SC02_000_jr_8015AE2C.c index cca0a8f9f..b79b65f00 100644 --- a/src/ov_SC02_000/ov_SC02_000_jr_8015AE2C.c +++ b/src/ov_SC02_000/ov_SC02_000_jr_8015AE2C.c @@ -4482,7 +4482,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018D830[]; + extern u32 D_8018D850, D_8018D854, D_8018D858, D_8018D85C; + extern u32 D_8018D850, D_8018D854, D_8018D858, D_8018D85C; + extern u32 D_8018D850, D_8018D854, D_8018D858, D_8018D85C; + extern u32 D_8018D850, D_8018D854, D_8018D858, D_8018D85C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018D830[0x00], p); + ApplyMatrixSV(mat, &D_8018D830[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018D830[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018D830[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018D858; + *(u32 *)(prim + 0x24) = D_8018D850; + *(u32 *)(prim + 0x28) = D_8018D85C; + *(u32 *)(prim + 0x2c) = D_8018D854; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_003/ov_SC02_003_jr_8015AE2C.c b/src/ov_SC02_003/ov_SC02_003_jr_8015AE2C.c index c9ade857f..a51976d8e 100644 --- a/src/ov_SC02_003/ov_SC02_003_jr_8015AE2C.c +++ b/src/ov_SC02_003/ov_SC02_003_jr_8015AE2C.c @@ -4482,7 +4482,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_003/nonmatchings/ov_SC02_003_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018D830[]; + extern u32 D_8018D850, D_8018D854, D_8018D858, D_8018D85C; + extern u32 D_8018D850, D_8018D854, D_8018D858, D_8018D85C; + extern u32 D_8018D850, D_8018D854, D_8018D858, D_8018D85C; + extern u32 D_8018D850, D_8018D854, D_8018D858, D_8018D85C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018D830[0x00], p); + ApplyMatrixSV(mat, &D_8018D830[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018D830[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018D830[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018D858; + *(u32 *)(prim + 0x24) = D_8018D850; + *(u32 *)(prim + 0x28) = D_8018D85C; + *(u32 *)(prim + 0x2c) = D_8018D854; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_004/ov_SC02_004_jr_8015AE2C.c b/src/ov_SC02_004/ov_SC02_004_jr_8015AE2C.c index b9c68e1d3..3a1addb77 100644 --- a/src/ov_SC02_004/ov_SC02_004_jr_8015AE2C.c +++ b/src/ov_SC02_004/ov_SC02_004_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_004/nonmatchings/ov_SC02_004_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80180910[]; + extern u32 D_80180930, D_80180934, D_80180938, D_8018093C; + extern u32 D_80180930, D_80180934, D_80180938, D_8018093C; + extern u32 D_80180930, D_80180934, D_80180938, D_8018093C; + extern u32 D_80180930, D_80180934, D_80180938, D_8018093C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80180910[0x00], p); + ApplyMatrixSV(mat, &D_80180910[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80180910[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80180910[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80180938; + *(u32 *)(prim + 0x24) = D_80180930; + *(u32 *)(prim + 0x28) = D_8018093C; + *(u32 *)(prim + 0x2c) = D_80180934; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8015AE2C.c b/src/ov_SC02_005/ov_SC02_005_jr_8015AE2C.c index a182df5b5..d294f4add 100644 --- a/src/ov_SC02_005/ov_SC02_005_jr_8015AE2C.c +++ b/src/ov_SC02_005/ov_SC02_005_jr_8015AE2C.c @@ -4482,7 +4482,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80193514[]; + extern u32 D_80193534, D_80193538, D_8019353C, D_80193540; + extern u32 D_80193534, D_80193538, D_8019353C, D_80193540; + extern u32 D_80193534, D_80193538, D_8019353C, D_80193540; + extern u32 D_80193534, D_80193538, D_8019353C, D_80193540; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80193514[0x00], p); + ApplyMatrixSV(mat, &D_80193514[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80193514[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80193514[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8019353C; + *(u32 *)(prim + 0x24) = D_80193534; + *(u32 *)(prim + 0x28) = D_80193540; + *(u32 *)(prim + 0x2c) = D_80193538; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_011/ov_SC02_011_jr_8015AE2C.c b/src/ov_SC02_011/ov_SC02_011_jr_8015AE2C.c index 6ac75b807..ac00fe833 100644 --- a/src/ov_SC02_011/ov_SC02_011_jr_8015AE2C.c +++ b/src/ov_SC02_011/ov_SC02_011_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80193964[]; + extern u32 D_80193984, D_80193988, D_8019398C, D_80193990; + extern u32 D_80193984, D_80193988, D_8019398C, D_80193990; + extern u32 D_80193984, D_80193988, D_8019398C, D_80193990; + extern u32 D_80193984, D_80193988, D_8019398C, D_80193990; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80193964[0x00], p); + ApplyMatrixSV(mat, &D_80193964[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80193964[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80193964[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8019398C; + *(u32 *)(prim + 0x24) = D_80193984; + *(u32 *)(prim + 0x28) = D_80193990; + *(u32 *)(prim + 0x2c) = D_80193988; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_015/ov_SC02_015_jr_8015AE2C.c b/src/ov_SC02_015/ov_SC02_015_jr_8015AE2C.c index 901e857f4..66ecfabe2 100644 --- a/src/ov_SC02_015/ov_SC02_015_jr_8015AE2C.c +++ b/src/ov_SC02_015/ov_SC02_015_jr_8015AE2C.c @@ -4482,7 +4482,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_015/nonmatchings/ov_SC02_015_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80180E78[]; + extern u32 D_80180E98, D_80180E9C, D_80180EA0, D_80180EA4; + extern u32 D_80180E98, D_80180E9C, D_80180EA0, D_80180EA4; + extern u32 D_80180E98, D_80180E9C, D_80180EA0, D_80180EA4; + extern u32 D_80180E98, D_80180E9C, D_80180EA0, D_80180EA4; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80180E78[0x00], p); + ApplyMatrixSV(mat, &D_80180E78[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80180E78[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80180E78[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80180EA0; + *(u32 *)(prim + 0x24) = D_80180E98; + *(u32 *)(prim + 0x28) = D_80180EA4; + *(u32 *)(prim + 0x2c) = D_80180E9C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_016/ov_SC02_016_jr_8015AE2C.c b/src/ov_SC02_016/ov_SC02_016_jr_8015AE2C.c index d6fe533bc..7a4c45de5 100644 --- a/src/ov_SC02_016/ov_SC02_016_jr_8015AE2C.c +++ b/src/ov_SC02_016/ov_SC02_016_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801870B0[]; + extern u32 D_801870D0, D_801870D4, D_801870D8, D_801870DC; + extern u32 D_801870D0, D_801870D4, D_801870D8, D_801870DC; + extern u32 D_801870D0, D_801870D4, D_801870D8, D_801870DC; + extern u32 D_801870D0, D_801870D4, D_801870D8, D_801870DC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801870B0[0x00], p); + ApplyMatrixSV(mat, &D_801870B0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801870B0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801870B0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801870D8; + *(u32 *)(prim + 0x24) = D_801870D0; + *(u32 *)(prim + 0x28) = D_801870DC; + *(u32 *)(prim + 0x2c) = D_801870D4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_017/ov_SC02_017_jr_8015AE2C.c b/src/ov_SC02_017/ov_SC02_017_jr_8015AE2C.c index 555dec7f5..9d4278e5f 100644 --- a/src/ov_SC02_017/ov_SC02_017_jr_8015AE2C.c +++ b/src/ov_SC02_017/ov_SC02_017_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018D108[]; + extern u32 D_8018D128, D_8018D12C, D_8018D130, D_8018D134; + extern u32 D_8018D128, D_8018D12C, D_8018D130, D_8018D134; + extern u32 D_8018D128, D_8018D12C, D_8018D130, D_8018D134; + extern u32 D_8018D128, D_8018D12C, D_8018D130, D_8018D134; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018D108[0x00], p); + ApplyMatrixSV(mat, &D_8018D108[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018D108[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018D108[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018D130; + *(u32 *)(prim + 0x24) = D_8018D128; + *(u32 *)(prim + 0x28) = D_8018D134; + *(u32 *)(prim + 0x2c) = D_8018D12C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_021/ov_SC02_021_jr_8015AE2C.c b/src/ov_SC02_021/ov_SC02_021_jr_8015AE2C.c index 8fc49d428..d80888bf1 100644 --- a/src/ov_SC02_021/ov_SC02_021_jr_8015AE2C.c +++ b/src/ov_SC02_021/ov_SC02_021_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801826FC[]; + extern u32 D_8018271C, D_80182720, D_80182724, D_80182728; + extern u32 D_8018271C, D_80182720, D_80182724, D_80182728; + extern u32 D_8018271C, D_80182720, D_80182724, D_80182728; + extern u32 D_8018271C, D_80182720, D_80182724, D_80182728; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801826FC[0x00], p); + ApplyMatrixSV(mat, &D_801826FC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801826FC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801826FC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80182724; + *(u32 *)(prim + 0x24) = D_8018271C; + *(u32 *)(prim + 0x28) = D_80182728; + *(u32 *)(prim + 0x2c) = D_80182720; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_026/ov_SC02_026_jr_8015AE2C.c b/src/ov_SC02_026/ov_SC02_026_jr_8015AE2C.c index 524d42b42..9ce669845 100644 --- a/src/ov_SC02_026/ov_SC02_026_jr_8015AE2C.c +++ b/src/ov_SC02_026/ov_SC02_026_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_026/nonmatchings/ov_SC02_026_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80188D50[]; + extern u32 D_80188D70, D_80188D74, D_80188D78, D_80188D7C; + extern u32 D_80188D70, D_80188D74, D_80188D78, D_80188D7C; + extern u32 D_80188D70, D_80188D74, D_80188D78, D_80188D7C; + extern u32 D_80188D70, D_80188D74, D_80188D78, D_80188D7C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80188D50[0x00], p); + ApplyMatrixSV(mat, &D_80188D50[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80188D50[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80188D50[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80188D78; + *(u32 *)(prim + 0x24) = D_80188D70; + *(u32 *)(prim + 0x28) = D_80188D7C; + *(u32 *)(prim + 0x2c) = D_80188D74; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_027/ov_SC02_027_jr_8015AE2C.c b/src/ov_SC02_027/ov_SC02_027_jr_8015AE2C.c index 5cd4b9032..8a2c09257 100644 --- a/src/ov_SC02_027/ov_SC02_027_jr_8015AE2C.c +++ b/src/ov_SC02_027/ov_SC02_027_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018DE74[]; + extern u32 D_8018DE94, D_8018DE98, D_8018DE9C, D_8018DEA0; + extern u32 D_8018DE94, D_8018DE98, D_8018DE9C, D_8018DEA0; + extern u32 D_8018DE94, D_8018DE98, D_8018DE9C, D_8018DEA0; + extern u32 D_8018DE94, D_8018DE98, D_8018DE9C, D_8018DEA0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018DE74[0x00], p); + ApplyMatrixSV(mat, &D_8018DE74[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018DE74[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018DE74[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018DE9C; + *(u32 *)(prim + 0x24) = D_8018DE94; + *(u32 *)(prim + 0x28) = D_8018DEA0; + *(u32 *)(prim + 0x2c) = D_8018DE98; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_028/ov_SC02_028_jr_8015AE2C.c b/src/ov_SC02_028/ov_SC02_028_jr_8015AE2C.c index f6a5071ba..57aaf57ad 100644 --- a/src/ov_SC02_028/ov_SC02_028_jr_8015AE2C.c +++ b/src/ov_SC02_028/ov_SC02_028_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018E078[]; + extern u32 D_8018E098, D_8018E09C, D_8018E0A0, D_8018E0A4; + extern u32 D_8018E098, D_8018E09C, D_8018E0A0, D_8018E0A4; + extern u32 D_8018E098, D_8018E09C, D_8018E0A0, D_8018E0A4; + extern u32 D_8018E098, D_8018E09C, D_8018E0A0, D_8018E0A4; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018E078[0x00], p); + ApplyMatrixSV(mat, &D_8018E078[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018E078[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018E078[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018E0A0; + *(u32 *)(prim + 0x24) = D_8018E098; + *(u32 *)(prim + 0x28) = D_8018E0A4; + *(u32 *)(prim + 0x2c) = D_8018E09C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_031/ov_SC02_031_jr_8015AE2C.c b/src/ov_SC02_031/ov_SC02_031_jr_8015AE2C.c index 393dc2507..c5a0e10d5 100644 --- a/src/ov_SC02_031/ov_SC02_031_jr_8015AE2C.c +++ b/src/ov_SC02_031/ov_SC02_031_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_031/nonmatchings/ov_SC02_031_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801878A4[]; + extern u32 D_801878C4, D_801878C8, D_801878CC, D_801878D0; + extern u32 D_801878C4, D_801878C8, D_801878CC, D_801878D0; + extern u32 D_801878C4, D_801878C8, D_801878CC, D_801878D0; + extern u32 D_801878C4, D_801878C8, D_801878CC, D_801878D0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801878A4[0x00], p); + ApplyMatrixSV(mat, &D_801878A4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801878A4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801878A4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801878CC; + *(u32 *)(prim + 0x24) = D_801878C4; + *(u32 *)(prim + 0x28) = D_801878D0; + *(u32 *)(prim + 0x2c) = D_801878C8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_035/ov_SC02_035_jr_8015AE2C.c b/src/ov_SC02_035/ov_SC02_035_jr_8015AE2C.c index d43948cd4..ff5299abc 100644 --- a/src/ov_SC02_035/ov_SC02_035_jr_8015AE2C.c +++ b/src/ov_SC02_035/ov_SC02_035_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_035/nonmatchings/ov_SC02_035_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80187104[]; + extern u32 D_80187124, D_80187128, D_8018712C, D_80187130; + extern u32 D_80187124, D_80187128, D_8018712C, D_80187130; + extern u32 D_80187124, D_80187128, D_8018712C, D_80187130; + extern u32 D_80187124, D_80187128, D_8018712C, D_80187130; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80187104[0x00], p); + ApplyMatrixSV(mat, &D_80187104[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80187104[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80187104[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018712C; + *(u32 *)(prim + 0x24) = D_80187124; + *(u32 *)(prim + 0x28) = D_80187130; + *(u32 *)(prim + 0x2c) = D_80187128; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_039/ov_SC02_039_jr_8015AE2C.c b/src/ov_SC02_039/ov_SC02_039_jr_8015AE2C.c index f0ab3102d..4ebd14705 100644 --- a/src/ov_SC02_039/ov_SC02_039_jr_8015AE2C.c +++ b/src/ov_SC02_039/ov_SC02_039_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_039/nonmatchings/ov_SC02_039_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181D30[]; + extern u32 D_80181D50, D_80181D54, D_80181D58, D_80181D5C; + extern u32 D_80181D50, D_80181D54, D_80181D58, D_80181D5C; + extern u32 D_80181D50, D_80181D54, D_80181D58, D_80181D5C; + extern u32 D_80181D50, D_80181D54, D_80181D58, D_80181D5C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181D30[0x00], p); + ApplyMatrixSV(mat, &D_80181D30[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181D30[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181D30[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181D58; + *(u32 *)(prim + 0x24) = D_80181D50; + *(u32 *)(prim + 0x28) = D_80181D5C; + *(u32 *)(prim + 0x2c) = D_80181D54; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC02_041/ov_SC02_041_jr_8015AE2C.c b/src/ov_SC02_041/ov_SC02_041_jr_8015AE2C.c index 1ddee9701..7f643ad3e 100644 --- a/src/ov_SC02_041/ov_SC02_041_jr_8015AE2C.c +++ b/src/ov_SC02_041/ov_SC02_041_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC02_041/nonmatchings/ov_SC02_041_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80187A00[]; + extern u32 D_80187A20, D_80187A24, D_80187A28, D_80187A2C; + extern u32 D_80187A20, D_80187A24, D_80187A28, D_80187A2C; + extern u32 D_80187A20, D_80187A24, D_80187A28, D_80187A2C; + extern u32 D_80187A20, D_80187A24, D_80187A28, D_80187A2C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80187A00[0x00], p); + ApplyMatrixSV(mat, &D_80187A00[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80187A00[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80187A00[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80187A28; + *(u32 *)(prim + 0x24) = D_80187A20; + *(u32 *)(prim + 0x28) = D_80187A2C; + *(u32 *)(prim + 0x2c) = D_80187A24; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_001/ov_SC03_001_jr_8015AE2C.c b/src/ov_SC03_001/ov_SC03_001_jr_8015AE2C.c index ea4743251..78a151b47 100644 --- a/src/ov_SC03_001/ov_SC03_001_jr_8015AE2C.c +++ b/src/ov_SC03_001/ov_SC03_001_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_001/nonmatchings/ov_SC03_001_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80190140[]; + extern u32 D_80190160, D_80190164, D_80190168, D_8019016C; + extern u32 D_80190160, D_80190164, D_80190168, D_8019016C; + extern u32 D_80190160, D_80190164, D_80190168, D_8019016C; + extern u32 D_80190160, D_80190164, D_80190168, D_8019016C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80190140[0x00], p); + ApplyMatrixSV(mat, &D_80190140[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80190140[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80190140[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80190168; + *(u32 *)(prim + 0x24) = D_80190160; + *(u32 *)(prim + 0x28) = D_8019016C; + *(u32 *)(prim + 0x2c) = D_80190164; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_002/ov_SC03_002_jr_8015AE2C.c b/src/ov_SC03_002/ov_SC03_002_jr_8015AE2C.c index 056db19c1..85f405ccd 100644 --- a/src/ov_SC03_002/ov_SC03_002_jr_8015AE2C.c +++ b/src/ov_SC03_002/ov_SC03_002_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_002/nonmatchings/ov_SC03_002_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80188130[]; + extern u32 D_80188150, D_80188154, D_80188158, D_8018815C; + extern u32 D_80188150, D_80188154, D_80188158, D_8018815C; + extern u32 D_80188150, D_80188154, D_80188158, D_8018815C; + extern u32 D_80188150, D_80188154, D_80188158, D_8018815C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80188130[0x00], p); + ApplyMatrixSV(mat, &D_80188130[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80188130[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80188130[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80188158; + *(u32 *)(prim + 0x24) = D_80188150; + *(u32 *)(prim + 0x28) = D_8018815C; + *(u32 *)(prim + 0x2c) = D_80188154; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_003/ov_SC03_003_jr_8015AE2C.c b/src/ov_SC03_003/ov_SC03_003_jr_8015AE2C.c index 893c8b03a..9bc11ce9b 100644 --- a/src/ov_SC03_003/ov_SC03_003_jr_8015AE2C.c +++ b/src/ov_SC03_003/ov_SC03_003_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_003/nonmatchings/ov_SC03_003_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181EF8[]; + extern u32 D_80181F18, D_80181F1C, D_80181F20, D_80181F24; + extern u32 D_80181F18, D_80181F1C, D_80181F20, D_80181F24; + extern u32 D_80181F18, D_80181F1C, D_80181F20, D_80181F24; + extern u32 D_80181F18, D_80181F1C, D_80181F20, D_80181F24; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181EF8[0x00], p); + ApplyMatrixSV(mat, &D_80181EF8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181EF8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181EF8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181F20; + *(u32 *)(prim + 0x24) = D_80181F18; + *(u32 *)(prim + 0x28) = D_80181F24; + *(u32 *)(prim + 0x2c) = D_80181F1C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_006/ov_SC03_006_jr_8015AE2C.c b/src/ov_SC03_006/ov_SC03_006_jr_8015AE2C.c index 028a59e08..fda5d3f0c 100644 --- a/src/ov_SC03_006/ov_SC03_006_jr_8015AE2C.c +++ b/src/ov_SC03_006/ov_SC03_006_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018F214[]; + extern u32 D_8018F234, D_8018F238, D_8018F23C, D_8018F240; + extern u32 D_8018F234, D_8018F238, D_8018F23C, D_8018F240; + extern u32 D_8018F234, D_8018F238, D_8018F23C, D_8018F240; + extern u32 D_8018F234, D_8018F238, D_8018F23C, D_8018F240; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018F214[0x00], p); + ApplyMatrixSV(mat, &D_8018F214[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018F214[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018F214[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018F23C; + *(u32 *)(prim + 0x24) = D_8018F234; + *(u32 *)(prim + 0x28) = D_8018F240; + *(u32 *)(prim + 0x2c) = D_8018F238; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_007/ov_SC03_007_jr_8015AE2C.c b/src/ov_SC03_007/ov_SC03_007_jr_8015AE2C.c index 29072f98f..befbb2e3f 100644 --- a/src/ov_SC03_007/ov_SC03_007_jr_8015AE2C.c +++ b/src/ov_SC03_007/ov_SC03_007_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018A00C[]; + extern u32 D_8018A02C, D_8018A030, D_8018A034, D_8018A038; + extern u32 D_8018A02C, D_8018A030, D_8018A034, D_8018A038; + extern u32 D_8018A02C, D_8018A030, D_8018A034, D_8018A038; + extern u32 D_8018A02C, D_8018A030, D_8018A034, D_8018A038; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018A00C[0x00], p); + ApplyMatrixSV(mat, &D_8018A00C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018A00C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018A00C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018A034; + *(u32 *)(prim + 0x24) = D_8018A02C; + *(u32 *)(prim + 0x28) = D_8018A038; + *(u32 *)(prim + 0x2c) = D_8018A030; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_010/ov_SC03_010_jr_8015AE2C.c b/src/ov_SC03_010/ov_SC03_010_jr_8015AE2C.c index 09832e84c..55fbb7ca7 100644 --- a/src/ov_SC03_010/ov_SC03_010_jr_8015AE2C.c +++ b/src/ov_SC03_010/ov_SC03_010_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_010/nonmatchings/ov_SC03_010_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80182B2C[]; + extern u32 D_80182B4C, D_80182B50, D_80182B54, D_80182B58; + extern u32 D_80182B4C, D_80182B50, D_80182B54, D_80182B58; + extern u32 D_80182B4C, D_80182B50, D_80182B54, D_80182B58; + extern u32 D_80182B4C, D_80182B50, D_80182B54, D_80182B58; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80182B2C[0x00], p); + ApplyMatrixSV(mat, &D_80182B2C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80182B2C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80182B2C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80182B54; + *(u32 *)(prim + 0x24) = D_80182B4C; + *(u32 *)(prim + 0x28) = D_80182B58; + *(u32 *)(prim + 0x2c) = D_80182B50; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_011/ov_SC03_011_jr_8015AE2C.c b/src/ov_SC03_011/ov_SC03_011_jr_8015AE2C.c index 2a7bc67b8..4717b5f07 100644 --- a/src/ov_SC03_011/ov_SC03_011_jr_8015AE2C.c +++ b/src/ov_SC03_011/ov_SC03_011_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80183E9C[]; + extern u32 D_80183EBC, D_80183EC0, D_80183EC4, D_80183EC8; + extern u32 D_80183EBC, D_80183EC0, D_80183EC4, D_80183EC8; + extern u32 D_80183EBC, D_80183EC0, D_80183EC4, D_80183EC8; + extern u32 D_80183EBC, D_80183EC0, D_80183EC4, D_80183EC8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80183E9C[0x00], p); + ApplyMatrixSV(mat, &D_80183E9C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80183E9C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80183E9C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80183EC4; + *(u32 *)(prim + 0x24) = D_80183EBC; + *(u32 *)(prim + 0x28) = D_80183EC8; + *(u32 *)(prim + 0x2c) = D_80183EC0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_012/ov_SC03_012_jr_8015AE2C.c b/src/ov_SC03_012/ov_SC03_012_jr_8015AE2C.c index 2faf44e89..71d71bdbb 100644 --- a/src/ov_SC03_012/ov_SC03_012_jr_8015AE2C.c +++ b/src/ov_SC03_012/ov_SC03_012_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_012/nonmatchings/ov_SC03_012_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80180D7C[]; + extern u32 D_80180D9C, D_80180DA0, D_80180DA4, D_80180DA8; + extern u32 D_80180D9C, D_80180DA0, D_80180DA4, D_80180DA8; + extern u32 D_80180D9C, D_80180DA0, D_80180DA4, D_80180DA8; + extern u32 D_80180D9C, D_80180DA0, D_80180DA4, D_80180DA8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80180D7C[0x00], p); + ApplyMatrixSV(mat, &D_80180D7C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80180D7C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80180D7C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80180DA4; + *(u32 *)(prim + 0x24) = D_80180D9C; + *(u32 *)(prim + 0x28) = D_80180DA8; + *(u32 *)(prim + 0x2c) = D_80180DA0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_013/ov_SC03_013_jr_8015AE2C.c b/src/ov_SC03_013/ov_SC03_013_jr_8015AE2C.c index 214e41b2d..99ee1db28 100644 --- a/src/ov_SC03_013/ov_SC03_013_jr_8015AE2C.c +++ b/src/ov_SC03_013/ov_SC03_013_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_013/nonmatchings/ov_SC03_013_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80183B64[]; + extern u32 D_80183B84, D_80183B88, D_80183B8C, D_80183B90; + extern u32 D_80183B84, D_80183B88, D_80183B8C, D_80183B90; + extern u32 D_80183B84, D_80183B88, D_80183B8C, D_80183B90; + extern u32 D_80183B84, D_80183B88, D_80183B8C, D_80183B90; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80183B64[0x00], p); + ApplyMatrixSV(mat, &D_80183B64[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80183B64[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80183B64[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80183B8C; + *(u32 *)(prim + 0x24) = D_80183B84; + *(u32 *)(prim + 0x28) = D_80183B90; + *(u32 *)(prim + 0x2c) = D_80183B88; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.c b/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.c index d03201316..4b0eb0e98 100644 --- a/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.c +++ b/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_014/nonmatchings/ov_SC03_014_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018E1A0[]; + extern u32 D_8018E1C0, D_8018E1C4, D_8018E1C8, D_8018E1CC; + extern u32 D_8018E1C0, D_8018E1C4, D_8018E1C8, D_8018E1CC; + extern u32 D_8018E1C0, D_8018E1C4, D_8018E1C8, D_8018E1CC; + extern u32 D_8018E1C0, D_8018E1C4, D_8018E1C8, D_8018E1CC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018E1A0[0x00], p); + ApplyMatrixSV(mat, &D_8018E1A0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018E1A0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018E1A0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018E1C8; + *(u32 *)(prim + 0x24) = D_8018E1C0; + *(u32 *)(prim + 0x28) = D_8018E1CC; + *(u32 *)(prim + 0x2c) = D_8018E1C4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.c b/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.c index 7e2451fa7..92c5f46cc 100644 --- a/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.c +++ b/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018E1A0[]; + extern u32 D_8018E1C0, D_8018E1C4, D_8018E1C8, D_8018E1CC; + extern u32 D_8018E1C0, D_8018E1C4, D_8018E1C8, D_8018E1CC; + extern u32 D_8018E1C0, D_8018E1C4, D_8018E1C8, D_8018E1CC; + extern u32 D_8018E1C0, D_8018E1C4, D_8018E1C8, D_8018E1CC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018E1A0[0x00], p); + ApplyMatrixSV(mat, &D_8018E1A0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018E1A0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018E1A0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018E1C8; + *(u32 *)(prim + 0x24) = D_8018E1C0; + *(u32 *)(prim + 0x28) = D_8018E1CC; + *(u32 *)(prim + 0x2c) = D_8018E1C4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_023/ov_SC03_023_jr_8015AE2C.c b/src/ov_SC03_023/ov_SC03_023_jr_8015AE2C.c index 6312500b5..ea411c531 100644 --- a/src/ov_SC03_023/ov_SC03_023_jr_8015AE2C.c +++ b/src/ov_SC03_023/ov_SC03_023_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181B1C[]; + extern u32 D_80181B3C, D_80181B40, D_80181B44, D_80181B48; + extern u32 D_80181B3C, D_80181B40, D_80181B44, D_80181B48; + extern u32 D_80181B3C, D_80181B40, D_80181B44, D_80181B48; + extern u32 D_80181B3C, D_80181B40, D_80181B44, D_80181B48; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181B1C[0x00], p); + ApplyMatrixSV(mat, &D_80181B1C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181B1C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181B1C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181B44; + *(u32 *)(prim + 0x24) = D_80181B3C; + *(u32 *)(prim + 0x28) = D_80181B48; + *(u32 *)(prim + 0x2c) = D_80181B40; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_024/ov_SC03_024_jr_8015AE2C.c b/src/ov_SC03_024/ov_SC03_024_jr_8015AE2C.c index 2c1306dcd..308939390 100644 --- a/src/ov_SC03_024/ov_SC03_024_jr_8015AE2C.c +++ b/src/ov_SC03_024/ov_SC03_024_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_024/nonmatchings/ov_SC03_024_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80189B40[]; + extern u32 D_80189B60, D_80189B64, D_80189B68, D_80189B6C; + extern u32 D_80189B60, D_80189B64, D_80189B68, D_80189B6C; + extern u32 D_80189B60, D_80189B64, D_80189B68, D_80189B6C; + extern u32 D_80189B60, D_80189B64, D_80189B68, D_80189B6C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80189B40[0x00], p); + ApplyMatrixSV(mat, &D_80189B40[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80189B40[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80189B40[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80189B68; + *(u32 *)(prim + 0x24) = D_80189B60; + *(u32 *)(prim + 0x28) = D_80189B6C; + *(u32 *)(prim + 0x2c) = D_80189B64; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_028/ov_SC03_028_jr_8015AE2C.c b/src/ov_SC03_028/ov_SC03_028_jr_8015AE2C.c index 814fe90d2..d817dd4cb 100644 --- a/src/ov_SC03_028/ov_SC03_028_jr_8015AE2C.c +++ b/src/ov_SC03_028/ov_SC03_028_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018E60C[]; + extern u32 D_8018E62C, D_8018E630, D_8018E634, D_8018E638; + extern u32 D_8018E62C, D_8018E630, D_8018E634, D_8018E638; + extern u32 D_8018E62C, D_8018E630, D_8018E634, D_8018E638; + extern u32 D_8018E62C, D_8018E630, D_8018E634, D_8018E638; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018E60C[0x00], p); + ApplyMatrixSV(mat, &D_8018E60C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018E60C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018E60C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018E634; + *(u32 *)(prim + 0x24) = D_8018E62C; + *(u32 *)(prim + 0x28) = D_8018E638; + *(u32 *)(prim + 0x2c) = D_8018E630; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_029/ov_SC03_029_jr_8015AE2C.c b/src/ov_SC03_029/ov_SC03_029_jr_8015AE2C.c index 38494fd1a..a0053ab27 100644 --- a/src/ov_SC03_029/ov_SC03_029_jr_8015AE2C.c +++ b/src/ov_SC03_029/ov_SC03_029_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018A444[]; + extern u32 D_8018A464, D_8018A468, D_8018A46C, D_8018A470; + extern u32 D_8018A464, D_8018A468, D_8018A46C, D_8018A470; + extern u32 D_8018A464, D_8018A468, D_8018A46C, D_8018A470; + extern u32 D_8018A464, D_8018A468, D_8018A46C, D_8018A470; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018A444[0x00], p); + ApplyMatrixSV(mat, &D_8018A444[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018A444[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018A444[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018A46C; + *(u32 *)(prim + 0x24) = D_8018A464; + *(u32 *)(prim + 0x28) = D_8018A470; + *(u32 *)(prim + 0x2c) = D_8018A468; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_030/ov_SC03_030_jr_8015AE2C.c b/src/ov_SC03_030/ov_SC03_030_jr_8015AE2C.c index b076954d7..70c376da3 100644 --- a/src/ov_SC03_030/ov_SC03_030_jr_8015AE2C.c +++ b/src/ov_SC03_030/ov_SC03_030_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_030/nonmatchings/ov_SC03_030_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80184A80[]; + extern u32 D_80184AA0, D_80184AA4, D_80184AA8, D_80184AAC; + extern u32 D_80184AA0, D_80184AA4, D_80184AA8, D_80184AAC; + extern u32 D_80184AA0, D_80184AA4, D_80184AA8, D_80184AAC; + extern u32 D_80184AA0, D_80184AA4, D_80184AA8, D_80184AAC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80184A80[0x00], p); + ApplyMatrixSV(mat, &D_80184A80[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80184A80[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80184A80[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80184AA8; + *(u32 *)(prim + 0x24) = D_80184AA0; + *(u32 *)(prim + 0x28) = D_80184AAC; + *(u32 *)(prim + 0x2c) = D_80184AA4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_031/ov_SC03_031_jr_8015AE2C.c b/src/ov_SC03_031/ov_SC03_031_jr_8015AE2C.c index 048380a8d..490ebf923 100644 --- a/src/ov_SC03_031/ov_SC03_031_jr_8015AE2C.c +++ b/src/ov_SC03_031/ov_SC03_031_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80184F9C[]; + extern u32 D_80184FBC, D_80184FC0, D_80184FC4, D_80184FC8; + extern u32 D_80184FBC, D_80184FC0, D_80184FC4, D_80184FC8; + extern u32 D_80184FBC, D_80184FC0, D_80184FC4, D_80184FC8; + extern u32 D_80184FBC, D_80184FC0, D_80184FC4, D_80184FC8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80184F9C[0x00], p); + ApplyMatrixSV(mat, &D_80184F9C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80184F9C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80184F9C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80184FC4; + *(u32 *)(prim + 0x24) = D_80184FBC; + *(u32 *)(prim + 0x28) = D_80184FC8; + *(u32 *)(prim + 0x2c) = D_80184FC0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_089/ov_SC03_089_jr_8015AE2C.c b/src/ov_SC03_089/ov_SC03_089_jr_8015AE2C.c index 83d960e19..78997f9b6 100644 --- a/src/ov_SC03_089/ov_SC03_089_jr_8015AE2C.c +++ b/src/ov_SC03_089/ov_SC03_089_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_089/nonmatchings/ov_SC03_089_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018C298[]; + extern u32 D_8018C2B8, D_8018C2BC, D_8018C2C0, D_8018C2C4; + extern u32 D_8018C2B8, D_8018C2BC, D_8018C2C0, D_8018C2C4; + extern u32 D_8018C2B8, D_8018C2BC, D_8018C2C0, D_8018C2C4; + extern u32 D_8018C2B8, D_8018C2BC, D_8018C2C0, D_8018C2C4; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018C298[0x00], p); + ApplyMatrixSV(mat, &D_8018C298[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018C298[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018C298[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018C2C0; + *(u32 *)(prim + 0x24) = D_8018C2B8; + *(u32 *)(prim + 0x28) = D_8018C2C4; + *(u32 *)(prim + 0x2c) = D_8018C2BC; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_090/ov_SC03_090_jr_8015AE2C.c b/src/ov_SC03_090/ov_SC03_090_jr_8015AE2C.c index a7bd568b7..2a87e0df7 100644 --- a/src/ov_SC03_090/ov_SC03_090_jr_8015AE2C.c +++ b/src/ov_SC03_090/ov_SC03_090_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018E6BC[]; + extern u32 D_8018E6DC, D_8018E6E0, D_8018E6E4, D_8018E6E8; + extern u32 D_8018E6DC, D_8018E6E0, D_8018E6E4, D_8018E6E8; + extern u32 D_8018E6DC, D_8018E6E0, D_8018E6E4, D_8018E6E8; + extern u32 D_8018E6DC, D_8018E6E0, D_8018E6E4, D_8018E6E8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018E6BC[0x00], p); + ApplyMatrixSV(mat, &D_8018E6BC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018E6BC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018E6BC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018E6E4; + *(u32 *)(prim + 0x24) = D_8018E6DC; + *(u32 *)(prim + 0x28) = D_8018E6E8; + *(u32 *)(prim + 0x2c) = D_8018E6E0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_091/ov_SC03_091_jr_8015AE2C.c b/src/ov_SC03_091/ov_SC03_091_jr_8015AE2C.c index 4a8ca7458..75ea29817 100644 --- a/src/ov_SC03_091/ov_SC03_091_jr_8015AE2C.c +++ b/src/ov_SC03_091/ov_SC03_091_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_091/nonmatchings/ov_SC03_091_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018F564[]; + extern u32 D_8018F584, D_8018F588, D_8018F58C, D_8018F590; + extern u32 D_8018F584, D_8018F588, D_8018F58C, D_8018F590; + extern u32 D_8018F584, D_8018F588, D_8018F58C, D_8018F590; + extern u32 D_8018F584, D_8018F588, D_8018F58C, D_8018F590; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018F564[0x00], p); + ApplyMatrixSV(mat, &D_8018F564[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018F564[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018F564[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018F58C; + *(u32 *)(prim + 0x24) = D_8018F584; + *(u32 *)(prim + 0x28) = D_8018F590; + *(u32 *)(prim + 0x2c) = D_8018F588; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_092/ov_SC03_092_jr_8015AE2C.c b/src/ov_SC03_092/ov_SC03_092_jr_8015AE2C.c index 15ded500c..a61e237d4 100644 --- a/src/ov_SC03_092/ov_SC03_092_jr_8015AE2C.c +++ b/src/ov_SC03_092/ov_SC03_092_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_092/nonmatchings/ov_SC03_092_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80187934[]; + extern u32 D_80187954, D_80187958, D_8018795C, D_80187960; + extern u32 D_80187954, D_80187958, D_8018795C, D_80187960; + extern u32 D_80187954, D_80187958, D_8018795C, D_80187960; + extern u32 D_80187954, D_80187958, D_8018795C, D_80187960; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80187934[0x00], p); + ApplyMatrixSV(mat, &D_80187934[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80187934[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80187934[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018795C; + *(u32 *)(prim + 0x24) = D_80187954; + *(u32 *)(prim + 0x28) = D_80187960; + *(u32 *)(prim + 0x2c) = D_80187958; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_093/ov_SC03_093_jr_8015AE2C.c b/src/ov_SC03_093/ov_SC03_093_jr_8015AE2C.c index a252e940e..3d2358578 100644 --- a/src/ov_SC03_093/ov_SC03_093_jr_8015AE2C.c +++ b/src/ov_SC03_093/ov_SC03_093_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_093/nonmatchings/ov_SC03_093_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80188B0C[]; + extern u32 D_80188B2C, D_80188B30, D_80188B34, D_80188B38; + extern u32 D_80188B2C, D_80188B30, D_80188B34, D_80188B38; + extern u32 D_80188B2C, D_80188B30, D_80188B34, D_80188B38; + extern u32 D_80188B2C, D_80188B30, D_80188B34, D_80188B38; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80188B0C[0x00], p); + ApplyMatrixSV(mat, &D_80188B0C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80188B0C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80188B0C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80188B34; + *(u32 *)(prim + 0x24) = D_80188B2C; + *(u32 *)(prim + 0x28) = D_80188B38; + *(u32 *)(prim + 0x2c) = D_80188B30; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_094/ov_SC03_094_jr_8015AE2C.c b/src/ov_SC03_094/ov_SC03_094_jr_8015AE2C.c index d022d1241..8bb5c922c 100644 --- a/src/ov_SC03_094/ov_SC03_094_jr_8015AE2C.c +++ b/src/ov_SC03_094/ov_SC03_094_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_094/nonmatchings/ov_SC03_094_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018A508[]; + extern u32 D_8018A528, D_8018A52C, D_8018A530, D_8018A534; + extern u32 D_8018A528, D_8018A52C, D_8018A530, D_8018A534; + extern u32 D_8018A528, D_8018A52C, D_8018A530, D_8018A534; + extern u32 D_8018A528, D_8018A52C, D_8018A530, D_8018A534; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018A508[0x00], p); + ApplyMatrixSV(mat, &D_8018A508[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018A508[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018A508[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018A530; + *(u32 *)(prim + 0x24) = D_8018A528; + *(u32 *)(prim + 0x28) = D_8018A534; + *(u32 *)(prim + 0x2c) = D_8018A52C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_095/ov_SC03_095_jr_8015AE2C.c b/src/ov_SC03_095/ov_SC03_095_jr_8015AE2C.c index e3b673659..bbecddf85 100644 --- a/src/ov_SC03_095/ov_SC03_095_jr_8015AE2C.c +++ b/src/ov_SC03_095/ov_SC03_095_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_095/nonmatchings/ov_SC03_095_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80183B68[]; + extern u32 D_80183B88, D_80183B8C, D_80183B90, D_80183B94; + extern u32 D_80183B88, D_80183B8C, D_80183B90, D_80183B94; + extern u32 D_80183B88, D_80183B8C, D_80183B90, D_80183B94; + extern u32 D_80183B88, D_80183B8C, D_80183B90, D_80183B94; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80183B68[0x00], p); + ApplyMatrixSV(mat, &D_80183B68[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80183B68[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80183B68[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80183B90; + *(u32 *)(prim + 0x24) = D_80183B88; + *(u32 *)(prim + 0x28) = D_80183B94; + *(u32 *)(prim + 0x2c) = D_80183B8C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_096/ov_SC03_096_jr_8015AE2C.c b/src/ov_SC03_096/ov_SC03_096_jr_8015AE2C.c index d0372fadf..996be429d 100644 --- a/src/ov_SC03_096/ov_SC03_096_jr_8015AE2C.c +++ b/src/ov_SC03_096/ov_SC03_096_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801836E8[]; + extern u32 D_80183708, D_8018370C, D_80183710, D_80183714; + extern u32 D_80183708, D_8018370C, D_80183710, D_80183714; + extern u32 D_80183708, D_8018370C, D_80183710, D_80183714; + extern u32 D_80183708, D_8018370C, D_80183710, D_80183714; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801836E8[0x00], p); + ApplyMatrixSV(mat, &D_801836E8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801836E8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801836E8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80183710; + *(u32 *)(prim + 0x24) = D_80183708; + *(u32 *)(prim + 0x28) = D_80183714; + *(u32 *)(prim + 0x2c) = D_8018370C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_097/ov_SC03_097_jr_8015AE2C.c b/src/ov_SC03_097/ov_SC03_097_jr_8015AE2C.c index baa19e1e0..396e50d9d 100644 --- a/src/ov_SC03_097/ov_SC03_097_jr_8015AE2C.c +++ b/src/ov_SC03_097/ov_SC03_097_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_097/nonmatchings/ov_SC03_097_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80188AC8[]; + extern u32 D_80188AE8, D_80188AEC, D_80188AF0, D_80188AF4; + extern u32 D_80188AE8, D_80188AEC, D_80188AF0, D_80188AF4; + extern u32 D_80188AE8, D_80188AEC, D_80188AF0, D_80188AF4; + extern u32 D_80188AE8, D_80188AEC, D_80188AF0, D_80188AF4; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80188AC8[0x00], p); + ApplyMatrixSV(mat, &D_80188AC8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80188AC8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80188AC8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80188AF0; + *(u32 *)(prim + 0x24) = D_80188AE8; + *(u32 *)(prim + 0x28) = D_80188AF4; + *(u32 *)(prim + 0x2c) = D_80188AEC; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_098/ov_SC03_098_jr_8015AE2C.c b/src/ov_SC03_098/ov_SC03_098_jr_8015AE2C.c index aa7b98193..e50eb5261 100644 --- a/src/ov_SC03_098/ov_SC03_098_jr_8015AE2C.c +++ b/src/ov_SC03_098/ov_SC03_098_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_098/nonmatchings/ov_SC03_098_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80187F54[]; + extern u32 D_80187F74, D_80187F78, D_80187F7C, D_80187F80; + extern u32 D_80187F74, D_80187F78, D_80187F7C, D_80187F80; + extern u32 D_80187F74, D_80187F78, D_80187F7C, D_80187F80; + extern u32 D_80187F74, D_80187F78, D_80187F7C, D_80187F80; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80187F54[0x00], p); + ApplyMatrixSV(mat, &D_80187F54[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80187F54[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80187F54[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80187F7C; + *(u32 *)(prim + 0x24) = D_80187F74; + *(u32 *)(prim + 0x28) = D_80187F80; + *(u32 *)(prim + 0x2c) = D_80187F78; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_099/ov_SC03_099_jr_8015AE2C.c b/src/ov_SC03_099/ov_SC03_099_jr_8015AE2C.c index fc0f02a58..1f503b1f6 100644 --- a/src/ov_SC03_099/ov_SC03_099_jr_8015AE2C.c +++ b/src/ov_SC03_099/ov_SC03_099_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_099/nonmatchings/ov_SC03_099_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80186054[]; + extern u32 D_80186074, D_80186078, D_8018607C, D_80186080; + extern u32 D_80186074, D_80186078, D_8018607C, D_80186080; + extern u32 D_80186074, D_80186078, D_8018607C, D_80186080; + extern u32 D_80186074, D_80186078, D_8018607C, D_80186080; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80186054[0x00], p); + ApplyMatrixSV(mat, &D_80186054[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80186054[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80186054[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018607C; + *(u32 *)(prim + 0x24) = D_80186074; + *(u32 *)(prim + 0x28) = D_80186080; + *(u32 *)(prim + 0x2c) = D_80186078; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_100/ov_SC03_100_jr_8015AE2C.c b/src/ov_SC03_100/ov_SC03_100_jr_8015AE2C.c index b7fddb655..4b22fe63d 100644 --- a/src/ov_SC03_100/ov_SC03_100_jr_8015AE2C.c +++ b/src/ov_SC03_100/ov_SC03_100_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_100/nonmatchings/ov_SC03_100_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80187520[]; + extern u32 D_80187540, D_80187544, D_80187548, D_8018754C; + extern u32 D_80187540, D_80187544, D_80187548, D_8018754C; + extern u32 D_80187540, D_80187544, D_80187548, D_8018754C; + extern u32 D_80187540, D_80187544, D_80187548, D_8018754C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80187520[0x00], p); + ApplyMatrixSV(mat, &D_80187520[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80187520[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80187520[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80187548; + *(u32 *)(prim + 0x24) = D_80187540; + *(u32 *)(prim + 0x28) = D_8018754C; + *(u32 *)(prim + 0x2c) = D_80187544; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_101/ov_SC03_101_jr_8015AE2C.c b/src/ov_SC03_101/ov_SC03_101_jr_8015AE2C.c index 2bdde8482..ad96cdcb9 100644 --- a/src/ov_SC03_101/ov_SC03_101_jr_8015AE2C.c +++ b/src/ov_SC03_101/ov_SC03_101_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801864FC[]; + extern u32 D_8018651C, D_80186520, D_80186524, D_80186528; + extern u32 D_8018651C, D_80186520, D_80186524, D_80186528; + extern u32 D_8018651C, D_80186520, D_80186524, D_80186528; + extern u32 D_8018651C, D_80186520, D_80186524, D_80186528; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801864FC[0x00], p); + ApplyMatrixSV(mat, &D_801864FC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801864FC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801864FC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80186524; + *(u32 *)(prim + 0x24) = D_8018651C; + *(u32 *)(prim + 0x28) = D_80186528; + *(u32 *)(prim + 0x2c) = D_80186520; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_102/ov_SC03_102_jr_8015AE2C.c b/src/ov_SC03_102/ov_SC03_102_jr_8015AE2C.c index 4f131b2f1..996e057a9 100644 --- a/src/ov_SC03_102/ov_SC03_102_jr_8015AE2C.c +++ b/src/ov_SC03_102/ov_SC03_102_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_102/nonmatchings/ov_SC03_102_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80188DB4[]; + extern u32 D_80188DD4, D_80188DD8, D_80188DDC, D_80188DE0; + extern u32 D_80188DD4, D_80188DD8, D_80188DDC, D_80188DE0; + extern u32 D_80188DD4, D_80188DD8, D_80188DDC, D_80188DE0; + extern u32 D_80188DD4, D_80188DD8, D_80188DDC, D_80188DE0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80188DB4[0x00], p); + ApplyMatrixSV(mat, &D_80188DB4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80188DB4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80188DB4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80188DDC; + *(u32 *)(prim + 0x24) = D_80188DD4; + *(u32 *)(prim + 0x28) = D_80188DE0; + *(u32 *)(prim + 0x2c) = D_80188DD8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_103/ov_SC03_103_jr_8015AE2C.c b/src/ov_SC03_103/ov_SC03_103_jr_8015AE2C.c index f7fa4c323..b3e6c9002 100644 --- a/src/ov_SC03_103/ov_SC03_103_jr_8015AE2C.c +++ b/src/ov_SC03_103/ov_SC03_103_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_103/nonmatchings/ov_SC03_103_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80186D64[]; + extern u32 D_80186D84, D_80186D88, D_80186D8C, D_80186D90; + extern u32 D_80186D84, D_80186D88, D_80186D8C, D_80186D90; + extern u32 D_80186D84, D_80186D88, D_80186D8C, D_80186D90; + extern u32 D_80186D84, D_80186D88, D_80186D8C, D_80186D90; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80186D64[0x00], p); + ApplyMatrixSV(mat, &D_80186D64[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80186D64[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80186D64[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80186D8C; + *(u32 *)(prim + 0x24) = D_80186D84; + *(u32 *)(prim + 0x28) = D_80186D90; + *(u32 *)(prim + 0x2c) = D_80186D88; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_104/ov_SC03_104_jr_8015AE2C.c b/src/ov_SC03_104/ov_SC03_104_jr_8015AE2C.c index dd25dceb1..808e80724 100644 --- a/src/ov_SC03_104/ov_SC03_104_jr_8015AE2C.c +++ b/src/ov_SC03_104/ov_SC03_104_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_104/nonmatchings/ov_SC03_104_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018D8F4[]; + extern u32 D_8018D914, D_8018D918, D_8018D91C, D_8018D920; + extern u32 D_8018D914, D_8018D918, D_8018D91C, D_8018D920; + extern u32 D_8018D914, D_8018D918, D_8018D91C, D_8018D920; + extern u32 D_8018D914, D_8018D918, D_8018D91C, D_8018D920; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018D8F4[0x00], p); + ApplyMatrixSV(mat, &D_8018D8F4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018D8F4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018D8F4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018D91C; + *(u32 *)(prim + 0x24) = D_8018D914; + *(u32 *)(prim + 0x28) = D_8018D920; + *(u32 *)(prim + 0x2c) = D_8018D918; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_105/ov_SC03_105_jr_8015AE2C.c b/src/ov_SC03_105/ov_SC03_105_jr_8015AE2C.c index 887e97d3e..9b585b331 100644 --- a/src/ov_SC03_105/ov_SC03_105_jr_8015AE2C.c +++ b/src/ov_SC03_105/ov_SC03_105_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018CF7C[]; + extern u32 D_8018CF9C, D_8018CFA0, D_8018CFA4, D_8018CFA8; + extern u32 D_8018CF9C, D_8018CFA0, D_8018CFA4, D_8018CFA8; + extern u32 D_8018CF9C, D_8018CFA0, D_8018CFA4, D_8018CFA8; + extern u32 D_8018CF9C, D_8018CFA0, D_8018CFA4, D_8018CFA8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018CF7C[0x00], p); + ApplyMatrixSV(mat, &D_8018CF7C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018CF7C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018CF7C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018CFA4; + *(u32 *)(prim + 0x24) = D_8018CF9C; + *(u32 *)(prim + 0x28) = D_8018CFA8; + *(u32 *)(prim + 0x2c) = D_8018CFA0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_108/ov_SC03_108_jr_8015AE2C.c b/src/ov_SC03_108/ov_SC03_108_jr_8015AE2C.c index 9947e962b..27d6711cd 100644 --- a/src/ov_SC03_108/ov_SC03_108_jr_8015AE2C.c +++ b/src/ov_SC03_108/ov_SC03_108_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801838D4[]; + extern u32 D_801838F4, D_801838F8, D_801838FC, D_80183900; + extern u32 D_801838F4, D_801838F8, D_801838FC, D_80183900; + extern u32 D_801838F4, D_801838F8, D_801838FC, D_80183900; + extern u32 D_801838F4, D_801838F8, D_801838FC, D_80183900; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801838D4[0x00], p); + ApplyMatrixSV(mat, &D_801838D4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801838D4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801838D4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801838FC; + *(u32 *)(prim + 0x24) = D_801838F4; + *(u32 *)(prim + 0x28) = D_80183900; + *(u32 *)(prim + 0x2c) = D_801838F8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_109/ov_SC03_109_jr_8015AE2C.c b/src/ov_SC03_109/ov_SC03_109_jr_8015AE2C.c index f1b16eb11..c04284e57 100644 --- a/src/ov_SC03_109/ov_SC03_109_jr_8015AE2C.c +++ b/src/ov_SC03_109/ov_SC03_109_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_109/nonmatchings/ov_SC03_109_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80180F80[]; + extern u32 D_80180FA0, D_80180FA4, D_80180FA8, D_80180FAC; + extern u32 D_80180FA0, D_80180FA4, D_80180FA8, D_80180FAC; + extern u32 D_80180FA0, D_80180FA4, D_80180FA8, D_80180FAC; + extern u32 D_80180FA0, D_80180FA4, D_80180FA8, D_80180FAC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80180F80[0x00], p); + ApplyMatrixSV(mat, &D_80180F80[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80180F80[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80180F80[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80180FA8; + *(u32 *)(prim + 0x24) = D_80180FA0; + *(u32 *)(prim + 0x28) = D_80180FAC; + *(u32 *)(prim + 0x2c) = D_80180FA4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_110/ov_SC03_110_jr_8015AE2C.c b/src/ov_SC03_110/ov_SC03_110_jr_8015AE2C.c index 9066972fb..f5f70a0ef 100644 --- a/src/ov_SC03_110/ov_SC03_110_jr_8015AE2C.c +++ b/src/ov_SC03_110/ov_SC03_110_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_110/nonmatchings/ov_SC03_110_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801849A0[]; + extern u32 D_801849C0, D_801849C4, D_801849C8, D_801849CC; + extern u32 D_801849C0, D_801849C4, D_801849C8, D_801849CC; + extern u32 D_801849C0, D_801849C4, D_801849C8, D_801849CC; + extern u32 D_801849C0, D_801849C4, D_801849C8, D_801849CC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801849A0[0x00], p); + ApplyMatrixSV(mat, &D_801849A0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801849A0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801849A0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801849C8; + *(u32 *)(prim + 0x24) = D_801849C0; + *(u32 *)(prim + 0x28) = D_801849CC; + *(u32 *)(prim + 0x2c) = D_801849C4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_111/ov_SC03_111_jr_8015AE2C.c b/src/ov_SC03_111/ov_SC03_111_jr_8015AE2C.c index daedc1f1b..3f722ece2 100644 --- a/src/ov_SC03_111/ov_SC03_111_jr_8015AE2C.c +++ b/src/ov_SC03_111/ov_SC03_111_jr_8015AE2C.c @@ -4484,7 +4484,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_111/nonmatchings/ov_SC03_111_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80187554[]; + extern u32 D_80187574, D_80187578, D_8018757C, D_80187580; + extern u32 D_80187574, D_80187578, D_8018757C, D_80187580; + extern u32 D_80187574, D_80187578, D_8018757C, D_80187580; + extern u32 D_80187574, D_80187578, D_8018757C, D_80187580; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80187554[0x00], p); + ApplyMatrixSV(mat, &D_80187554[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80187554[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80187554[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018757C; + *(u32 *)(prim + 0x24) = D_80187574; + *(u32 *)(prim + 0x28) = D_80187580; + *(u32 *)(prim + 0x2c) = D_80187578; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_112/ov_SC03_112_jr_8015AE2C.c b/src/ov_SC03_112/ov_SC03_112_jr_8015AE2C.c index 4b36cf557..c9dea9d8f 100644 --- a/src/ov_SC03_112/ov_SC03_112_jr_8015AE2C.c +++ b/src/ov_SC03_112/ov_SC03_112_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_112/nonmatchings/ov_SC03_112_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018835C[]; + extern u32 D_8018837C, D_80188380, D_80188384, D_80188388; + extern u32 D_8018837C, D_80188380, D_80188384, D_80188388; + extern u32 D_8018837C, D_80188380, D_80188384, D_80188388; + extern u32 D_8018837C, D_80188380, D_80188384, D_80188388; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018835C[0x00], p); + ApplyMatrixSV(mat, &D_8018835C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018835C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018835C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80188384; + *(u32 *)(prim + 0x24) = D_8018837C; + *(u32 *)(prim + 0x28) = D_80188388; + *(u32 *)(prim + 0x2c) = D_80188380; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_113/ov_SC03_113_jr_8015AE2C.c b/src/ov_SC03_113/ov_SC03_113_jr_8015AE2C.c index b96fb1684..158120195 100644 --- a/src/ov_SC03_113/ov_SC03_113_jr_8015AE2C.c +++ b/src/ov_SC03_113/ov_SC03_113_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_113/nonmatchings/ov_SC03_113_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80185A0C[]; + extern u32 D_80185A2C, D_80185A30, D_80185A34, D_80185A38; + extern u32 D_80185A2C, D_80185A30, D_80185A34, D_80185A38; + extern u32 D_80185A2C, D_80185A30, D_80185A34, D_80185A38; + extern u32 D_80185A2C, D_80185A30, D_80185A34, D_80185A38; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80185A0C[0x00], p); + ApplyMatrixSV(mat, &D_80185A0C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80185A0C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80185A0C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80185A34; + *(u32 *)(prim + 0x24) = D_80185A2C; + *(u32 *)(prim + 0x28) = D_80185A38; + *(u32 *)(prim + 0x2c) = D_80185A30; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_114/ov_SC03_114_jr_8015AE2C.c b/src/ov_SC03_114/ov_SC03_114_jr_8015AE2C.c index 6e821dfab..0f5d66ffe 100644 --- a/src/ov_SC03_114/ov_SC03_114_jr_8015AE2C.c +++ b/src/ov_SC03_114/ov_SC03_114_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_114/nonmatchings/ov_SC03_114_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181674[]; + extern u32 D_80181694, D_80181698, D_8018169C, D_801816A0; + extern u32 D_80181694, D_80181698, D_8018169C, D_801816A0; + extern u32 D_80181694, D_80181698, D_8018169C, D_801816A0; + extern u32 D_80181694, D_80181698, D_8018169C, D_801816A0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181674[0x00], p); + ApplyMatrixSV(mat, &D_80181674[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181674[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181674[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018169C; + *(u32 *)(prim + 0x24) = D_80181694; + *(u32 *)(prim + 0x28) = D_801816A0; + *(u32 *)(prim + 0x2c) = D_80181698; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_115/ov_SC03_115_jr_8015AE2C.c b/src/ov_SC03_115/ov_SC03_115_jr_8015AE2C.c index 25ee1ccea..307b4c163 100644 --- a/src/ov_SC03_115/ov_SC03_115_jr_8015AE2C.c +++ b/src/ov_SC03_115/ov_SC03_115_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801830E0[]; + extern u32 D_80183100, D_80183104, D_80183108, D_8018310C; + extern u32 D_80183100, D_80183104, D_80183108, D_8018310C; + extern u32 D_80183100, D_80183104, D_80183108, D_8018310C; + extern u32 D_80183100, D_80183104, D_80183108, D_8018310C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801830E0[0x00], p); + ApplyMatrixSV(mat, &D_801830E0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801830E0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801830E0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80183108; + *(u32 *)(prim + 0x24) = D_80183100; + *(u32 *)(prim + 0x28) = D_8018310C; + *(u32 *)(prim + 0x2c) = D_80183104; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_116/ov_SC03_116_jr_8015AE2C.c b/src/ov_SC03_116/ov_SC03_116_jr_8015AE2C.c index af2747e54..2ad91ef82 100644 --- a/src/ov_SC03_116/ov_SC03_116_jr_8015AE2C.c +++ b/src/ov_SC03_116/ov_SC03_116_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801854E4[]; + extern u32 D_80185504, D_80185508, D_8018550C, D_80185510; + extern u32 D_80185504, D_80185508, D_8018550C, D_80185510; + extern u32 D_80185504, D_80185508, D_8018550C, D_80185510; + extern u32 D_80185504, D_80185508, D_8018550C, D_80185510; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801854E4[0x00], p); + ApplyMatrixSV(mat, &D_801854E4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801854E4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801854E4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018550C; + *(u32 *)(prim + 0x24) = D_80185504; + *(u32 *)(prim + 0x28) = D_80185510; + *(u32 *)(prim + 0x2c) = D_80185508; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_117/ov_SC03_117_jr_8015AE2C.c b/src/ov_SC03_117/ov_SC03_117_jr_8015AE2C.c index ed5e46e3e..68bbea4f6 100644 --- a/src/ov_SC03_117/ov_SC03_117_jr_8015AE2C.c +++ b/src/ov_SC03_117/ov_SC03_117_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_117/nonmatchings/ov_SC03_117_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801874F0[]; + extern u32 D_80187510, D_80187514, D_80187518, D_8018751C; + extern u32 D_80187510, D_80187514, D_80187518, D_8018751C; + extern u32 D_80187510, D_80187514, D_80187518, D_8018751C; + extern u32 D_80187510, D_80187514, D_80187518, D_8018751C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801874F0[0x00], p); + ApplyMatrixSV(mat, &D_801874F0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801874F0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801874F0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80187518; + *(u32 *)(prim + 0x24) = D_80187510; + *(u32 *)(prim + 0x28) = D_8018751C; + *(u32 *)(prim + 0x2c) = D_80187514; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_118/ov_SC03_118_jr_8015AE2C.c b/src/ov_SC03_118/ov_SC03_118_jr_8015AE2C.c index 4d04449ad..168f6bd09 100644 --- a/src/ov_SC03_118/ov_SC03_118_jr_8015AE2C.c +++ b/src/ov_SC03_118/ov_SC03_118_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_118/nonmatchings/ov_SC03_118_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018C59C[]; + extern u32 D_8018C5BC, D_8018C5C0, D_8018C5C4, D_8018C5C8; + extern u32 D_8018C5BC, D_8018C5C0, D_8018C5C4, D_8018C5C8; + extern u32 D_8018C5BC, D_8018C5C0, D_8018C5C4, D_8018C5C8; + extern u32 D_8018C5BC, D_8018C5C0, D_8018C5C4, D_8018C5C8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018C59C[0x00], p); + ApplyMatrixSV(mat, &D_8018C59C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018C59C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018C59C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018C5C4; + *(u32 *)(prim + 0x24) = D_8018C5BC; + *(u32 *)(prim + 0x28) = D_8018C5C8; + *(u32 *)(prim + 0x2c) = D_8018C5C0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_119/ov_SC03_119_jr_8015AE2C.c b/src/ov_SC03_119/ov_SC03_119_jr_8015AE2C.c index 8760d80be..f2798998d 100644 --- a/src/ov_SC03_119/ov_SC03_119_jr_8015AE2C.c +++ b/src/ov_SC03_119/ov_SC03_119_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018C59C[]; + extern u32 D_8018C5BC, D_8018C5C0, D_8018C5C4, D_8018C5C8; + extern u32 D_8018C5BC, D_8018C5C0, D_8018C5C4, D_8018C5C8; + extern u32 D_8018C5BC, D_8018C5C0, D_8018C5C4, D_8018C5C8; + extern u32 D_8018C5BC, D_8018C5C0, D_8018C5C4, D_8018C5C8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018C59C[0x00], p); + ApplyMatrixSV(mat, &D_8018C59C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018C59C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018C59C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018C5C4; + *(u32 *)(prim + 0x24) = D_8018C5BC; + *(u32 *)(prim + 0x28) = D_8018C5C8; + *(u32 *)(prim + 0x2c) = D_8018C5C0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_121/ov_SC03_121_jr_8015AE2C.c b/src/ov_SC03_121/ov_SC03_121_jr_8015AE2C.c index 6f70b0d4a..8aab76054 100644 --- a/src/ov_SC03_121/ov_SC03_121_jr_8015AE2C.c +++ b/src/ov_SC03_121/ov_SC03_121_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_121/nonmatchings/ov_SC03_121_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80184DB8[]; + extern u32 D_80184DD8, D_80184DDC, D_80184DE0, D_80184DE4; + extern u32 D_80184DD8, D_80184DDC, D_80184DE0, D_80184DE4; + extern u32 D_80184DD8, D_80184DDC, D_80184DE0, D_80184DE4; + extern u32 D_80184DD8, D_80184DDC, D_80184DE0, D_80184DE4; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80184DB8[0x00], p); + ApplyMatrixSV(mat, &D_80184DB8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80184DB8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80184DB8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80184DE0; + *(u32 *)(prim + 0x24) = D_80184DD8; + *(u32 *)(prim + 0x28) = D_80184DE4; + *(u32 *)(prim + 0x2c) = D_80184DDC; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_124/ov_SC03_124_jr_8015AE2C.c b/src/ov_SC03_124/ov_SC03_124_jr_8015AE2C.c index 3a0c435e5..235039bd3 100644 --- a/src/ov_SC03_124/ov_SC03_124_jr_8015AE2C.c +++ b/src/ov_SC03_124/ov_SC03_124_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018D7E4[]; + extern u32 D_8018D804, D_8018D808, D_8018D80C, D_8018D810; + extern u32 D_8018D804, D_8018D808, D_8018D80C, D_8018D810; + extern u32 D_8018D804, D_8018D808, D_8018D80C, D_8018D810; + extern u32 D_8018D804, D_8018D808, D_8018D80C, D_8018D810; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018D7E4[0x00], p); + ApplyMatrixSV(mat, &D_8018D7E4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018D7E4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018D7E4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018D80C; + *(u32 *)(prim + 0x24) = D_8018D804; + *(u32 *)(prim + 0x28) = D_8018D810; + *(u32 *)(prim + 0x2c) = D_8018D808; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_125/ov_SC03_125_jr_8015AE2C.c b/src/ov_SC03_125/ov_SC03_125_jr_8015AE2C.c index ba7e815b5..92ba7bbc3 100644 --- a/src/ov_SC03_125/ov_SC03_125_jr_8015AE2C.c +++ b/src/ov_SC03_125/ov_SC03_125_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801869B4[]; + extern u32 D_801869D4, D_801869D8, D_801869DC, D_801869E0; + extern u32 D_801869D4, D_801869D8, D_801869DC, D_801869E0; + extern u32 D_801869D4, D_801869D8, D_801869DC, D_801869E0; + extern u32 D_801869D4, D_801869D8, D_801869DC, D_801869E0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801869B4[0x00], p); + ApplyMatrixSV(mat, &D_801869B4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801869B4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801869B4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801869DC; + *(u32 *)(prim + 0x24) = D_801869D4; + *(u32 *)(prim + 0x28) = D_801869E0; + *(u32 *)(prim + 0x2c) = D_801869D8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC03_126/ov_SC03_126_jr_8015AE2C.c b/src/ov_SC03_126/ov_SC03_126_jr_8015AE2C.c index 0c7e613f8..a27dd64f2 100644 --- a/src/ov_SC03_126/ov_SC03_126_jr_8015AE2C.c +++ b/src/ov_SC03_126/ov_SC03_126_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC03_126/nonmatchings/ov_SC03_126_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181EAC[]; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181EAC[0x00], p); + ApplyMatrixSV(mat, &D_80181EAC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181EAC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181EAC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181ED4; + *(u32 *)(prim + 0x24) = D_80181ECC; + *(u32 *)(prim + 0x28) = D_80181ED8; + *(u32 *)(prim + 0x2c) = D_80181ED0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_000/ov_SC04_000_jr_8015AE2C.c b/src/ov_SC04_000/ov_SC04_000_jr_8015AE2C.c index 445d1d066..cf091df85 100644 --- a/src/ov_SC04_000/ov_SC04_000_jr_8015AE2C.c +++ b/src/ov_SC04_000/ov_SC04_000_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_000/nonmatchings/ov_SC04_000_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80185EB8[]; + extern u32 D_80185ED8, D_80185EDC, D_80185EE0, D_80185EE4; + extern u32 D_80185ED8, D_80185EDC, D_80185EE0, D_80185EE4; + extern u32 D_80185ED8, D_80185EDC, D_80185EE0, D_80185EE4; + extern u32 D_80185ED8, D_80185EDC, D_80185EE0, D_80185EE4; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80185EB8[0x00], p); + ApplyMatrixSV(mat, &D_80185EB8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80185EB8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80185EB8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80185EE0; + *(u32 *)(prim + 0x24) = D_80185ED8; + *(u32 *)(prim + 0x28) = D_80185EE4; + *(u32 *)(prim + 0x2c) = D_80185EDC; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_002/ov_SC04_002_jr_8015AE2C.c b/src/ov_SC04_002/ov_SC04_002_jr_8015AE2C.c index 972b95d17..92d8cab14 100644 --- a/src/ov_SC04_002/ov_SC04_002_jr_8015AE2C.c +++ b/src/ov_SC04_002/ov_SC04_002_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018B024[]; + extern u32 D_8018B044, D_8018B048, D_8018B04C, D_8018B050; + extern u32 D_8018B044, D_8018B048, D_8018B04C, D_8018B050; + extern u32 D_8018B044, D_8018B048, D_8018B04C, D_8018B050; + extern u32 D_8018B044, D_8018B048, D_8018B04C, D_8018B050; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018B024[0x00], p); + ApplyMatrixSV(mat, &D_8018B024[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018B024[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018B024[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018B04C; + *(u32 *)(prim + 0x24) = D_8018B044; + *(u32 *)(prim + 0x28) = D_8018B050; + *(u32 *)(prim + 0x2c) = D_8018B048; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_003/ov_SC04_003_jr_8015AE2C.c b/src/ov_SC04_003/ov_SC04_003_jr_8015AE2C.c index af8814a73..5398fc6ad 100644 --- a/src/ov_SC04_003/ov_SC04_003_jr_8015AE2C.c +++ b/src/ov_SC04_003/ov_SC04_003_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_003/nonmatchings/ov_SC04_003_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80184DC0[]; + extern u32 D_80184DE0, D_80184DE4, D_80184DE8, D_80184DEC; + extern u32 D_80184DE0, D_80184DE4, D_80184DE8, D_80184DEC; + extern u32 D_80184DE0, D_80184DE4, D_80184DE8, D_80184DEC; + extern u32 D_80184DE0, D_80184DE4, D_80184DE8, D_80184DEC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80184DC0[0x00], p); + ApplyMatrixSV(mat, &D_80184DC0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80184DC0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80184DC0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80184DE8; + *(u32 *)(prim + 0x24) = D_80184DE0; + *(u32 *)(prim + 0x28) = D_80184DEC; + *(u32 *)(prim + 0x2c) = D_80184DE4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_004/ov_SC04_004_jr_8015AE2C.c b/src/ov_SC04_004/ov_SC04_004_jr_8015AE2C.c index 92238f1a1..b184965be 100644 --- a/src/ov_SC04_004/ov_SC04_004_jr_8015AE2C.c +++ b/src/ov_SC04_004/ov_SC04_004_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801872F4[]; + extern u32 D_80187314, D_80187318, D_8018731C, D_80187320; + extern u32 D_80187314, D_80187318, D_8018731C, D_80187320; + extern u32 D_80187314, D_80187318, D_8018731C, D_80187320; + extern u32 D_80187314, D_80187318, D_8018731C, D_80187320; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801872F4[0x00], p); + ApplyMatrixSV(mat, &D_801872F4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801872F4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801872F4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018731C; + *(u32 *)(prim + 0x24) = D_80187314; + *(u32 *)(prim + 0x28) = D_80187320; + *(u32 *)(prim + 0x2c) = D_80187318; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_005/ov_SC04_005_jr_8015AE2C.c b/src/ov_SC04_005/ov_SC04_005_jr_8015AE2C.c index aba20b021..fdb489d8a 100644 --- a/src/ov_SC04_005/ov_SC04_005_jr_8015AE2C.c +++ b/src/ov_SC04_005/ov_SC04_005_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018A728[]; + extern u32 D_8018A748, D_8018A74C, D_8018A750, D_8018A754; + extern u32 D_8018A748, D_8018A74C, D_8018A750, D_8018A754; + extern u32 D_8018A748, D_8018A74C, D_8018A750, D_8018A754; + extern u32 D_8018A748, D_8018A74C, D_8018A750, D_8018A754; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018A728[0x00], p); + ApplyMatrixSV(mat, &D_8018A728[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018A728[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018A728[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018A750; + *(u32 *)(prim + 0x24) = D_8018A748; + *(u32 *)(prim + 0x28) = D_8018A754; + *(u32 *)(prim + 0x2c) = D_8018A74C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_006/ov_SC04_006_jr_8015AE2C.c b/src/ov_SC04_006/ov_SC04_006_jr_8015AE2C.c index c3f9e2fe8..1ac8952bb 100644 --- a/src/ov_SC04_006/ov_SC04_006_jr_8015AE2C.c +++ b/src/ov_SC04_006/ov_SC04_006_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_006/nonmatchings/ov_SC04_006_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80182808[]; + extern u32 D_80182828, D_8018282C, D_80182830, D_80182834; + extern u32 D_80182828, D_8018282C, D_80182830, D_80182834; + extern u32 D_80182828, D_8018282C, D_80182830, D_80182834; + extern u32 D_80182828, D_8018282C, D_80182830, D_80182834; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80182808[0x00], p); + ApplyMatrixSV(mat, &D_80182808[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80182808[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80182808[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80182830; + *(u32 *)(prim + 0x24) = D_80182828; + *(u32 *)(prim + 0x28) = D_80182834; + *(u32 *)(prim + 0x2c) = D_8018282C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_007/ov_SC04_007_jr_8015AE2C.c b/src/ov_SC04_007/ov_SC04_007_jr_8015AE2C.c index 88ef31faf..9fa10feb0 100644 --- a/src/ov_SC04_007/ov_SC04_007_jr_8015AE2C.c +++ b/src/ov_SC04_007/ov_SC04_007_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801887C0[]; + extern u32 D_801887E0, D_801887E4, D_801887E8, D_801887EC; + extern u32 D_801887E0, D_801887E4, D_801887E8, D_801887EC; + extern u32 D_801887E0, D_801887E4, D_801887E8, D_801887EC; + extern u32 D_801887E0, D_801887E4, D_801887E8, D_801887EC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801887C0[0x00], p); + ApplyMatrixSV(mat, &D_801887C0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801887C0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801887C0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801887E8; + *(u32 *)(prim + 0x24) = D_801887E0; + *(u32 *)(prim + 0x28) = D_801887EC; + *(u32 *)(prim + 0x2c) = D_801887E4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_008/ov_SC04_008_jr_8015AE2C.c b/src/ov_SC04_008/ov_SC04_008_jr_8015AE2C.c index 1981a2654..6ee77a605 100644 --- a/src/ov_SC04_008/ov_SC04_008_jr_8015AE2C.c +++ b/src/ov_SC04_008/ov_SC04_008_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_008/nonmatchings/ov_SC04_008_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801816F8[]; + extern u32 D_80181718, D_8018171C, D_80181720, D_80181724; + extern u32 D_80181718, D_8018171C, D_80181720, D_80181724; + extern u32 D_80181718, D_8018171C, D_80181720, D_80181724; + extern u32 D_80181718, D_8018171C, D_80181720, D_80181724; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801816F8[0x00], p); + ApplyMatrixSV(mat, &D_801816F8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801816F8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801816F8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181720; + *(u32 *)(prim + 0x24) = D_80181718; + *(u32 *)(prim + 0x28) = D_80181724; + *(u32 *)(prim + 0x2c) = D_8018171C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_009/ov_SC04_009_jr_8015AE2C.c b/src/ov_SC04_009/ov_SC04_009_jr_8015AE2C.c index e517c716f..107eaeb51 100644 --- a/src/ov_SC04_009/ov_SC04_009_jr_8015AE2C.c +++ b/src/ov_SC04_009/ov_SC04_009_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_009/nonmatchings/ov_SC04_009_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181724[]; + extern u32 D_80181744, D_80181748, D_8018174C, D_80181750; + extern u32 D_80181744, D_80181748, D_8018174C, D_80181750; + extern u32 D_80181744, D_80181748, D_8018174C, D_80181750; + extern u32 D_80181744, D_80181748, D_8018174C, D_80181750; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181724[0x00], p); + ApplyMatrixSV(mat, &D_80181724[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181724[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181724[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018174C; + *(u32 *)(prim + 0x24) = D_80181744; + *(u32 *)(prim + 0x28) = D_80181750; + *(u32 *)(prim + 0x2c) = D_80181748; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_010/ov_SC04_010_jr_8015AE2C.c b/src/ov_SC04_010/ov_SC04_010_jr_8015AE2C.c index 2bef7e9c7..193dbb28f 100644 --- a/src/ov_SC04_010/ov_SC04_010_jr_8015AE2C.c +++ b/src/ov_SC04_010/ov_SC04_010_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_010/nonmatchings/ov_SC04_010_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80180DD0[]; + extern u32 D_80180DF0, D_80180DF4, D_80180DF8, D_80180DFC; + extern u32 D_80180DF0, D_80180DF4, D_80180DF8, D_80180DFC; + extern u32 D_80180DF0, D_80180DF4, D_80180DF8, D_80180DFC; + extern u32 D_80180DF0, D_80180DF4, D_80180DF8, D_80180DFC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80180DD0[0x00], p); + ApplyMatrixSV(mat, &D_80180DD0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80180DD0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80180DD0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80180DF8; + *(u32 *)(prim + 0x24) = D_80180DF0; + *(u32 *)(prim + 0x28) = D_80180DFC; + *(u32 *)(prim + 0x2c) = D_80180DF4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.c b/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.c index 62b48577e..a82e5be7e 100644 --- a/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.c +++ b/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80193060[]; + extern u32 D_80193080, D_80193084, D_80193088, D_8019308C; + extern u32 D_80193080, D_80193084, D_80193088, D_8019308C; + extern u32 D_80193080, D_80193084, D_80193088, D_8019308C; + extern u32 D_80193080, D_80193084, D_80193088, D_8019308C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80193060[0x00], p); + ApplyMatrixSV(mat, &D_80193060[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80193060[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80193060[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80193088; + *(u32 *)(prim + 0x24) = D_80193080; + *(u32 *)(prim + 0x28) = D_8019308C; + *(u32 *)(prim + 0x2c) = D_80193084; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_012/ov_SC04_012_jr_8015AE2C.c b/src/ov_SC04_012/ov_SC04_012_jr_8015AE2C.c index 9e08ee73e..b38940d75 100644 --- a/src/ov_SC04_012/ov_SC04_012_jr_8015AE2C.c +++ b/src/ov_SC04_012/ov_SC04_012_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_012/nonmatchings/ov_SC04_012_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181234[]; + extern u32 D_80181254, D_80181258, D_8018125C, D_80181260; + extern u32 D_80181254, D_80181258, D_8018125C, D_80181260; + extern u32 D_80181254, D_80181258, D_8018125C, D_80181260; + extern u32 D_80181254, D_80181258, D_8018125C, D_80181260; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181234[0x00], p); + ApplyMatrixSV(mat, &D_80181234[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181234[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181234[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018125C; + *(u32 *)(prim + 0x24) = D_80181254; + *(u32 *)(prim + 0x28) = D_80181260; + *(u32 *)(prim + 0x2c) = D_80181258; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_015/ov_SC04_015_jr_8015AE2C.c b/src/ov_SC04_015/ov_SC04_015_jr_8015AE2C.c index f5256dd74..052a456c9 100644 --- a/src/ov_SC04_015/ov_SC04_015_jr_8015AE2C.c +++ b/src/ov_SC04_015/ov_SC04_015_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_015/nonmatchings/ov_SC04_015_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018716C[]; + extern u32 D_8018718C, D_80187190, D_80187194, D_80187198; + extern u32 D_8018718C, D_80187190, D_80187194, D_80187198; + extern u32 D_8018718C, D_80187190, D_80187194, D_80187198; + extern u32 D_8018718C, D_80187190, D_80187194, D_80187198; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018716C[0x00], p); + ApplyMatrixSV(mat, &D_8018716C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018716C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018716C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80187194; + *(u32 *)(prim + 0x24) = D_8018718C; + *(u32 *)(prim + 0x28) = D_80187198; + *(u32 *)(prim + 0x2c) = D_80187190; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_016/ov_SC04_016_jr_8015AE2C.c b/src/ov_SC04_016/ov_SC04_016_jr_8015AE2C.c index 5f4e287ec..8a8ae06c9 100644 --- a/src/ov_SC04_016/ov_SC04_016_jr_8015AE2C.c +++ b/src/ov_SC04_016/ov_SC04_016_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_016/nonmatchings/ov_SC04_016_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80182C30[]; + extern u32 D_80182C50, D_80182C54, D_80182C58, D_80182C5C; + extern u32 D_80182C50, D_80182C54, D_80182C58, D_80182C5C; + extern u32 D_80182C50, D_80182C54, D_80182C58, D_80182C5C; + extern u32 D_80182C50, D_80182C54, D_80182C58, D_80182C5C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80182C30[0x00], p); + ApplyMatrixSV(mat, &D_80182C30[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80182C30[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80182C30[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80182C58; + *(u32 *)(prim + 0x24) = D_80182C50; + *(u32 *)(prim + 0x28) = D_80182C5C; + *(u32 *)(prim + 0x2c) = D_80182C54; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_018/ov_SC04_018_jr_8015AE2C.c b/src/ov_SC04_018/ov_SC04_018_jr_8015AE2C.c index 0358a680c..d5538990b 100644 --- a/src/ov_SC04_018/ov_SC04_018_jr_8015AE2C.c +++ b/src/ov_SC04_018/ov_SC04_018_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018FE48[]; + extern u32 D_8018FE68, D_8018FE6C, D_8018FE70, D_8018FE74; + extern u32 D_8018FE68, D_8018FE6C, D_8018FE70, D_8018FE74; + extern u32 D_8018FE68, D_8018FE6C, D_8018FE70, D_8018FE74; + extern u32 D_8018FE68, D_8018FE6C, D_8018FE70, D_8018FE74; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018FE48[0x00], p); + ApplyMatrixSV(mat, &D_8018FE48[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018FE48[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018FE48[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018FE70; + *(u32 *)(prim + 0x24) = D_8018FE68; + *(u32 *)(prim + 0x28) = D_8018FE74; + *(u32 *)(prim + 0x2c) = D_8018FE6C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_019/ov_SC04_019_jr_8015AE2C.c b/src/ov_SC04_019/ov_SC04_019_jr_8015AE2C.c index 2d854ffed..b46b4e473 100644 --- a/src/ov_SC04_019/ov_SC04_019_jr_8015AE2C.c +++ b/src/ov_SC04_019/ov_SC04_019_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018FE48[]; + extern u32 D_8018FE68, D_8018FE6C, D_8018FE70, D_8018FE74; + extern u32 D_8018FE68, D_8018FE6C, D_8018FE70, D_8018FE74; + extern u32 D_8018FE68, D_8018FE6C, D_8018FE70, D_8018FE74; + extern u32 D_8018FE68, D_8018FE6C, D_8018FE70, D_8018FE74; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018FE48[0x00], p); + ApplyMatrixSV(mat, &D_8018FE48[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018FE48[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018FE48[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018FE70; + *(u32 *)(prim + 0x24) = D_8018FE68; + *(u32 *)(prim + 0x28) = D_8018FE74; + *(u32 *)(prim + 0x2c) = D_8018FE6C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_020/ov_SC04_020_jr_8015AE2C.c b/src/ov_SC04_020/ov_SC04_020_jr_8015AE2C.c index 98e56b4a6..4b0d98df5 100644 --- a/src/ov_SC04_020/ov_SC04_020_jr_8015AE2C.c +++ b/src/ov_SC04_020/ov_SC04_020_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_020/nonmatchings/ov_SC04_020_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80185F80[]; + extern u32 D_80185FA0, D_80185FA4, D_80185FA8, D_80185FAC; + extern u32 D_80185FA0, D_80185FA4, D_80185FA8, D_80185FAC; + extern u32 D_80185FA0, D_80185FA4, D_80185FA8, D_80185FAC; + extern u32 D_80185FA0, D_80185FA4, D_80185FA8, D_80185FAC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80185F80[0x00], p); + ApplyMatrixSV(mat, &D_80185F80[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80185F80[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80185F80[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80185FA8; + *(u32 *)(prim + 0x24) = D_80185FA0; + *(u32 *)(prim + 0x28) = D_80185FAC; + *(u32 *)(prim + 0x2c) = D_80185FA4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC04_021/ov_SC04_021_jr_8015AE2C.c b/src/ov_SC04_021/ov_SC04_021_jr_8015AE2C.c index c7d02b1e2..739168e89 100644 --- a/src/ov_SC04_021/ov_SC04_021_jr_8015AE2C.c +++ b/src/ov_SC04_021/ov_SC04_021_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC04_021/nonmatchings/ov_SC04_021_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181EAC[]; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181EAC[0x00], p); + ApplyMatrixSV(mat, &D_80181EAC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181EAC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181EAC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181ED4; + *(u32 *)(prim + 0x24) = D_80181ECC; + *(u32 *)(prim + 0x28) = D_80181ED8; + *(u32 *)(prim + 0x2c) = D_80181ED0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_000/ov_SC05_000_jr_8015AE2C.c b/src/ov_SC05_000/ov_SC05_000_jr_8015AE2C.c index 3c4d4b34d..f80dd3c09 100644 --- a/src/ov_SC05_000/ov_SC05_000_jr_8015AE2C.c +++ b/src/ov_SC05_000/ov_SC05_000_jr_8015AE2C.c @@ -4461,7 +4461,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_000/nonmatchings/ov_SC05_000_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80180EC0[]; + extern u32 D_80180EE0, D_80180EE4, D_80180EE8, D_80180EEC; + extern u32 D_80180EE0, D_80180EE4, D_80180EE8, D_80180EEC; + extern u32 D_80180EE0, D_80180EE4, D_80180EE8, D_80180EEC; + extern u32 D_80180EE0, D_80180EE4, D_80180EE8, D_80180EEC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80180EC0[0x00], p); + ApplyMatrixSV(mat, &D_80180EC0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80180EC0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80180EC0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80180EE8; + *(u32 *)(prim + 0x24) = D_80180EE0; + *(u32 *)(prim + 0x28) = D_80180EEC; + *(u32 *)(prim + 0x2c) = D_80180EE4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_001/ov_SC05_001_jr_8015AE2C.c b/src/ov_SC05_001/ov_SC05_001_jr_8015AE2C.c index d30259c90..21b09b2e4 100644 --- a/src/ov_SC05_001/ov_SC05_001_jr_8015AE2C.c +++ b/src/ov_SC05_001/ov_SC05_001_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_001/nonmatchings/ov_SC05_001_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018869C[]; + extern u32 D_801886BC, D_801886C0, D_801886C4, D_801886C8; + extern u32 D_801886BC, D_801886C0, D_801886C4, D_801886C8; + extern u32 D_801886BC, D_801886C0, D_801886C4, D_801886C8; + extern u32 D_801886BC, D_801886C0, D_801886C4, D_801886C8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018869C[0x00], p); + ApplyMatrixSV(mat, &D_8018869C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018869C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018869C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801886C4; + *(u32 *)(prim + 0x24) = D_801886BC; + *(u32 *)(prim + 0x28) = D_801886C8; + *(u32 *)(prim + 0x2c) = D_801886C0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_002/ov_SC05_002_jr_8015AE2C.c b/src/ov_SC05_002/ov_SC05_002_jr_8015AE2C.c index 59fb12475..6041bdb38 100644 --- a/src/ov_SC05_002/ov_SC05_002_jr_8015AE2C.c +++ b/src/ov_SC05_002/ov_SC05_002_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80182E5C[]; + extern u32 D_80182E7C, D_80182E80, D_80182E84, D_80182E88; + extern u32 D_80182E7C, D_80182E80, D_80182E84, D_80182E88; + extern u32 D_80182E7C, D_80182E80, D_80182E84, D_80182E88; + extern u32 D_80182E7C, D_80182E80, D_80182E84, D_80182E88; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80182E5C[0x00], p); + ApplyMatrixSV(mat, &D_80182E5C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80182E5C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80182E5C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80182E84; + *(u32 *)(prim + 0x24) = D_80182E7C; + *(u32 *)(prim + 0x28) = D_80182E88; + *(u32 *)(prim + 0x2c) = D_80182E80; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_003/ov_SC05_003_jr_8015AE2C.c b/src/ov_SC05_003/ov_SC05_003_jr_8015AE2C.c index 0d63c175d..6b8c78dda 100644 --- a/src/ov_SC05_003/ov_SC05_003_jr_8015AE2C.c +++ b/src/ov_SC05_003/ov_SC05_003_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80185194[]; + extern u32 D_801851B4, D_801851B8, D_801851BC, D_801851C0; + extern u32 D_801851B4, D_801851B8, D_801851BC, D_801851C0; + extern u32 D_801851B4, D_801851B8, D_801851BC, D_801851C0; + extern u32 D_801851B4, D_801851B8, D_801851BC, D_801851C0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80185194[0x00], p); + ApplyMatrixSV(mat, &D_80185194[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80185194[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80185194[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801851BC; + *(u32 *)(prim + 0x24) = D_801851B4; + *(u32 *)(prim + 0x28) = D_801851C0; + *(u32 *)(prim + 0x2c) = D_801851B8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_004/ov_SC05_004_jr_8015AE2C.c b/src/ov_SC05_004/ov_SC05_004_jr_8015AE2C.c index 90f056fde..0139f370e 100644 --- a/src/ov_SC05_004/ov_SC05_004_jr_8015AE2C.c +++ b/src/ov_SC05_004/ov_SC05_004_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_004/nonmatchings/ov_SC05_004_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801842A0[]; + extern u32 D_801842C0, D_801842C4, D_801842C8, D_801842CC; + extern u32 D_801842C0, D_801842C4, D_801842C8, D_801842CC; + extern u32 D_801842C0, D_801842C4, D_801842C8, D_801842CC; + extern u32 D_801842C0, D_801842C4, D_801842C8, D_801842CC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801842A0[0x00], p); + ApplyMatrixSV(mat, &D_801842A0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801842A0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801842A0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801842C8; + *(u32 *)(prim + 0x24) = D_801842C0; + *(u32 *)(prim + 0x28) = D_801842CC; + *(u32 *)(prim + 0x2c) = D_801842C4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_005/ov_SC05_005_jr_8015AE2C.c b/src/ov_SC05_005/ov_SC05_005_jr_8015AE2C.c index 4c3b71fae..3e3f7b213 100644 --- a/src/ov_SC05_005/ov_SC05_005_jr_8015AE2C.c +++ b/src/ov_SC05_005/ov_SC05_005_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_005/nonmatchings/ov_SC05_005_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80185074[]; + extern u32 D_80185094, D_80185098, D_8018509C, D_801850A0; + extern u32 D_80185094, D_80185098, D_8018509C, D_801850A0; + extern u32 D_80185094, D_80185098, D_8018509C, D_801850A0; + extern u32 D_80185094, D_80185098, D_8018509C, D_801850A0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80185074[0x00], p); + ApplyMatrixSV(mat, &D_80185074[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80185074[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80185074[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018509C; + *(u32 *)(prim + 0x24) = D_80185094; + *(u32 *)(prim + 0x28) = D_801850A0; + *(u32 *)(prim + 0x2c) = D_80185098; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_006/ov_SC05_006_jr_8015AE2C.c b/src/ov_SC05_006/ov_SC05_006_jr_8015AE2C.c index 840432cb4..fbbfd7ebd 100644 --- a/src/ov_SC05_006/ov_SC05_006_jr_8015AE2C.c +++ b/src/ov_SC05_006/ov_SC05_006_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_006/nonmatchings/ov_SC05_006_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80182094[]; + extern u32 D_801820B4, D_801820B8, D_801820BC, D_801820C0; + extern u32 D_801820B4, D_801820B8, D_801820BC, D_801820C0; + extern u32 D_801820B4, D_801820B8, D_801820BC, D_801820C0; + extern u32 D_801820B4, D_801820B8, D_801820BC, D_801820C0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80182094[0x00], p); + ApplyMatrixSV(mat, &D_80182094[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80182094[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80182094[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801820BC; + *(u32 *)(prim + 0x24) = D_801820B4; + *(u32 *)(prim + 0x28) = D_801820C0; + *(u32 *)(prim + 0x2c) = D_801820B8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_007/ov_SC05_007_jr_8015AE2C.c b/src/ov_SC05_007/ov_SC05_007_jr_8015AE2C.c index 47525c575..bd21978dc 100644 --- a/src/ov_SC05_007/ov_SC05_007_jr_8015AE2C.c +++ b/src/ov_SC05_007/ov_SC05_007_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80183690[]; + extern u32 D_801836B0, D_801836B4, D_801836B8, D_801836BC; + extern u32 D_801836B0, D_801836B4, D_801836B8, D_801836BC; + extern u32 D_801836B0, D_801836B4, D_801836B8, D_801836BC; + extern u32 D_801836B0, D_801836B4, D_801836B8, D_801836BC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80183690[0x00], p); + ApplyMatrixSV(mat, &D_80183690[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80183690[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80183690[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801836B8; + *(u32 *)(prim + 0x24) = D_801836B0; + *(u32 *)(prim + 0x28) = D_801836BC; + *(u32 *)(prim + 0x2c) = D_801836B4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_008/ov_SC05_008_jr_8015AE2C.c b/src/ov_SC05_008/ov_SC05_008_jr_8015AE2C.c index d6f945583..fb3828fa7 100644 --- a/src/ov_SC05_008/ov_SC05_008_jr_8015AE2C.c +++ b/src/ov_SC05_008/ov_SC05_008_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801855E8[]; + extern u32 D_80185608, D_8018560C, D_80185610, D_80185614; + extern u32 D_80185608, D_8018560C, D_80185610, D_80185614; + extern u32 D_80185608, D_8018560C, D_80185610, D_80185614; + extern u32 D_80185608, D_8018560C, D_80185610, D_80185614; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801855E8[0x00], p); + ApplyMatrixSV(mat, &D_801855E8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801855E8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801855E8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80185610; + *(u32 *)(prim + 0x24) = D_80185608; + *(u32 *)(prim + 0x28) = D_80185614; + *(u32 *)(prim + 0x2c) = D_8018560C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_009/ov_SC05_009_jr_8015AE2C.c b/src/ov_SC05_009/ov_SC05_009_jr_8015AE2C.c index 5e2c8f73e..1e0acd7b4 100644 --- a/src/ov_SC05_009/ov_SC05_009_jr_8015AE2C.c +++ b/src/ov_SC05_009/ov_SC05_009_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_009/nonmatchings/ov_SC05_009_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801816F8[]; + extern u32 D_80181718, D_8018171C, D_80181720, D_80181724; + extern u32 D_80181718, D_8018171C, D_80181720, D_80181724; + extern u32 D_80181718, D_8018171C, D_80181720, D_80181724; + extern u32 D_80181718, D_8018171C, D_80181720, D_80181724; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801816F8[0x00], p); + ApplyMatrixSV(mat, &D_801816F8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801816F8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801816F8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181720; + *(u32 *)(prim + 0x24) = D_80181718; + *(u32 *)(prim + 0x28) = D_80181724; + *(u32 *)(prim + 0x2c) = D_8018171C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_010/ov_SC05_010_jr_8015AE2C.c b/src/ov_SC05_010/ov_SC05_010_jr_8015AE2C.c index 5bd627dc1..6c5d3f9e6 100644 --- a/src/ov_SC05_010/ov_SC05_010_jr_8015AE2C.c +++ b/src/ov_SC05_010/ov_SC05_010_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018B5D4[]; + extern u32 D_8018B5F4, D_8018B5F8, D_8018B5FC, D_8018B600; + extern u32 D_8018B5F4, D_8018B5F8, D_8018B5FC, D_8018B600; + extern u32 D_8018B5F4, D_8018B5F8, D_8018B5FC, D_8018B600; + extern u32 D_8018B5F4, D_8018B5F8, D_8018B5FC, D_8018B600; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018B5D4[0x00], p); + ApplyMatrixSV(mat, &D_8018B5D4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018B5D4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018B5D4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018B5FC; + *(u32 *)(prim + 0x24) = D_8018B5F4; + *(u32 *)(prim + 0x28) = D_8018B600; + *(u32 *)(prim + 0x2c) = D_8018B5F8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_011/ov_SC05_011_jr_8015AE2C.c b/src/ov_SC05_011/ov_SC05_011_jr_8015AE2C.c index 334978a55..c6ddaa4f4 100644 --- a/src/ov_SC05_011/ov_SC05_011_jr_8015AE2C.c +++ b/src/ov_SC05_011/ov_SC05_011_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_011/nonmatchings/ov_SC05_011_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018094C[]; + extern u32 D_8018096C, D_80180970, D_80180974, D_80180978; + extern u32 D_8018096C, D_80180970, D_80180974, D_80180978; + extern u32 D_8018096C, D_80180970, D_80180974, D_80180978; + extern u32 D_8018096C, D_80180970, D_80180974, D_80180978; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018094C[0x00], p); + ApplyMatrixSV(mat, &D_8018094C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018094C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018094C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80180974; + *(u32 *)(prim + 0x24) = D_8018096C; + *(u32 *)(prim + 0x28) = D_80180978; + *(u32 *)(prim + 0x2c) = D_80180970; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_017/ov_SC05_017_jr_8015AE2C.c b/src/ov_SC05_017/ov_SC05_017_jr_8015AE2C.c index 8bca7b7d3..8eec22406 100644 --- a/src/ov_SC05_017/ov_SC05_017_jr_8015AE2C.c +++ b/src/ov_SC05_017/ov_SC05_017_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_017/nonmatchings/ov_SC05_017_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018FE0C[]; + extern u32 D_8018FE2C, D_8018FE30, D_8018FE34, D_8018FE38; + extern u32 D_8018FE2C, D_8018FE30, D_8018FE34, D_8018FE38; + extern u32 D_8018FE2C, D_8018FE30, D_8018FE34, D_8018FE38; + extern u32 D_8018FE2C, D_8018FE30, D_8018FE34, D_8018FE38; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018FE0C[0x00], p); + ApplyMatrixSV(mat, &D_8018FE0C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018FE0C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018FE0C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018FE34; + *(u32 *)(prim + 0x24) = D_8018FE2C; + *(u32 *)(prim + 0x28) = D_8018FE38; + *(u32 *)(prim + 0x2c) = D_8018FE30; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_018/ov_SC05_018_jr_8015AE2C.c b/src/ov_SC05_018/ov_SC05_018_jr_8015AE2C.c index f524dc440..cd15033dc 100644 --- a/src/ov_SC05_018/ov_SC05_018_jr_8015AE2C.c +++ b/src/ov_SC05_018/ov_SC05_018_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80189568[]; + extern u32 D_80189588, D_8018958C, D_80189590, D_80189594; + extern u32 D_80189588, D_8018958C, D_80189590, D_80189594; + extern u32 D_80189588, D_8018958C, D_80189590, D_80189594; + extern u32 D_80189588, D_8018958C, D_80189590, D_80189594; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80189568[0x00], p); + ApplyMatrixSV(mat, &D_80189568[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80189568[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80189568[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80189590; + *(u32 *)(prim + 0x24) = D_80189588; + *(u32 *)(prim + 0x28) = D_80189594; + *(u32 *)(prim + 0x2c) = D_8018958C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC05_019/ov_SC05_019_jr_8015AE2C.c b/src/ov_SC05_019/ov_SC05_019_jr_8015AE2C.c index 997a8d2a9..c5cafe44c 100644 --- a/src/ov_SC05_019/ov_SC05_019_jr_8015AE2C.c +++ b/src/ov_SC05_019/ov_SC05_019_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC05_019/nonmatchings/ov_SC05_019_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181EAC[]; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + extern u32 D_80181ECC, D_80181ED0, D_80181ED4, D_80181ED8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181EAC[0x00], p); + ApplyMatrixSV(mat, &D_80181EAC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181EAC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181EAC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181ED4; + *(u32 *)(prim + 0x24) = D_80181ECC; + *(u32 *)(prim + 0x28) = D_80181ED8; + *(u32 *)(prim + 0x2c) = D_80181ED0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_000/ov_SC06_000_jr_8015AE2C.c b/src/ov_SC06_000/ov_SC06_000_jr_8015AE2C.c index f9c77ab8d..90ddf5e5c 100644 --- a/src/ov_SC06_000/ov_SC06_000_jr_8015AE2C.c +++ b/src/ov_SC06_000/ov_SC06_000_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018AEBC[]; + extern u32 D_8018AEDC, D_8018AEE0, D_8018AEE4, D_8018AEE8; + extern u32 D_8018AEDC, D_8018AEE0, D_8018AEE4, D_8018AEE8; + extern u32 D_8018AEDC, D_8018AEE0, D_8018AEE4, D_8018AEE8; + extern u32 D_8018AEDC, D_8018AEE0, D_8018AEE4, D_8018AEE8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018AEBC[0x00], p); + ApplyMatrixSV(mat, &D_8018AEBC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018AEBC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018AEBC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018AEE4; + *(u32 *)(prim + 0x24) = D_8018AEDC; + *(u32 *)(prim + 0x28) = D_8018AEE8; + *(u32 *)(prim + 0x2c) = D_8018AEE0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_006/ov_SC06_006_jr_8015AE2C.c b/src/ov_SC06_006/ov_SC06_006_jr_8015AE2C.c index c93cb2a6b..2a61542d0 100644 --- a/src/ov_SC06_006/ov_SC06_006_jr_8015AE2C.c +++ b/src/ov_SC06_006/ov_SC06_006_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801849E0[]; + extern u32 D_80184A00, D_80184A04, D_80184A08, D_80184A0C; + extern u32 D_80184A00, D_80184A04, D_80184A08, D_80184A0C; + extern u32 D_80184A00, D_80184A04, D_80184A08, D_80184A0C; + extern u32 D_80184A00, D_80184A04, D_80184A08, D_80184A0C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801849E0[0x00], p); + ApplyMatrixSV(mat, &D_801849E0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801849E0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801849E0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80184A08; + *(u32 *)(prim + 0x24) = D_80184A00; + *(u32 *)(prim + 0x28) = D_80184A0C; + *(u32 *)(prim + 0x2c) = D_80184A04; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_008/ov_SC06_008_jr_8015AE2C.c b/src/ov_SC06_008/ov_SC06_008_jr_8015AE2C.c index 0553e9bbe..7f1433782 100644 --- a/src/ov_SC06_008/ov_SC06_008_jr_8015AE2C.c +++ b/src/ov_SC06_008/ov_SC06_008_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_008/nonmatchings/ov_SC06_008_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80188448[]; + extern u32 D_80188468, D_8018846C, D_80188470, D_80188474; + extern u32 D_80188468, D_8018846C, D_80188470, D_80188474; + extern u32 D_80188468, D_8018846C, D_80188470, D_80188474; + extern u32 D_80188468, D_8018846C, D_80188470, D_80188474; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80188448[0x00], p); + ApplyMatrixSV(mat, &D_80188448[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80188448[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80188448[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80188470; + *(u32 *)(prim + 0x24) = D_80188468; + *(u32 *)(prim + 0x28) = D_80188474; + *(u32 *)(prim + 0x2c) = D_8018846C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_010/ov_SC06_010_jr_8015AE2C.c b/src/ov_SC06_010/ov_SC06_010_jr_8015AE2C.c index f3531600a..5e4e4f6cd 100644 --- a/src/ov_SC06_010/ov_SC06_010_jr_8015AE2C.c +++ b/src/ov_SC06_010/ov_SC06_010_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_010/nonmatchings/ov_SC06_010_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80189624[]; + extern u32 D_80189644, D_80189648, D_8018964C, D_80189650; + extern u32 D_80189644, D_80189648, D_8018964C, D_80189650; + extern u32 D_80189644, D_80189648, D_8018964C, D_80189650; + extern u32 D_80189644, D_80189648, D_8018964C, D_80189650; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80189624[0x00], p); + ApplyMatrixSV(mat, &D_80189624[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80189624[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80189624[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018964C; + *(u32 *)(prim + 0x24) = D_80189644; + *(u32 *)(prim + 0x28) = D_80189650; + *(u32 *)(prim + 0x2c) = D_80189648; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_011/ov_SC06_011_jr_8015AE2C.c b/src/ov_SC06_011/ov_SC06_011_jr_8015AE2C.c index d4c99acd0..16ef77936 100644 --- a/src/ov_SC06_011/ov_SC06_011_jr_8015AE2C.c +++ b/src/ov_SC06_011/ov_SC06_011_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_011/nonmatchings/ov_SC06_011_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80183084[]; + extern u32 D_801830A4, D_801830A8, D_801830AC, D_801830B0; + extern u32 D_801830A4, D_801830A8, D_801830AC, D_801830B0; + extern u32 D_801830A4, D_801830A8, D_801830AC, D_801830B0; + extern u32 D_801830A4, D_801830A8, D_801830AC, D_801830B0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80183084[0x00], p); + ApplyMatrixSV(mat, &D_80183084[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80183084[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80183084[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801830AC; + *(u32 *)(prim + 0x24) = D_801830A4; + *(u32 *)(prim + 0x28) = D_801830B0; + *(u32 *)(prim + 0x2c) = D_801830A8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_013/ov_SC06_013_jr_8015AE2C.c b/src/ov_SC06_013/ov_SC06_013_jr_8015AE2C.c index 3209881b4..e0fdccc37 100644 --- a/src/ov_SC06_013/ov_SC06_013_jr_8015AE2C.c +++ b/src/ov_SC06_013/ov_SC06_013_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_013/nonmatchings/ov_SC06_013_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80181800[]; + extern u32 D_80181820, D_80181824, D_80181828, D_8018182C; + extern u32 D_80181820, D_80181824, D_80181828, D_8018182C; + extern u32 D_80181820, D_80181824, D_80181828, D_8018182C; + extern u32 D_80181820, D_80181824, D_80181828, D_8018182C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80181800[0x00], p); + ApplyMatrixSV(mat, &D_80181800[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80181800[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80181800[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80181828; + *(u32 *)(prim + 0x24) = D_80181820; + *(u32 *)(prim + 0x28) = D_8018182C; + *(u32 *)(prim + 0x2c) = D_80181824; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_014/ov_SC06_014_jr_8015AE2C.c b/src/ov_SC06_014/ov_SC06_014_jr_8015AE2C.c index 7006d0eb6..c5ef11a78 100644 --- a/src/ov_SC06_014/ov_SC06_014_jr_8015AE2C.c +++ b/src/ov_SC06_014/ov_SC06_014_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_014/nonmatchings/ov_SC06_014_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80182B64[]; + extern u32 D_80182B84, D_80182B88, D_80182B8C, D_80182B90; + extern u32 D_80182B84, D_80182B88, D_80182B8C, D_80182B90; + extern u32 D_80182B84, D_80182B88, D_80182B8C, D_80182B90; + extern u32 D_80182B84, D_80182B88, D_80182B8C, D_80182B90; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80182B64[0x00], p); + ApplyMatrixSV(mat, &D_80182B64[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80182B64[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80182B64[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80182B8C; + *(u32 *)(prim + 0x24) = D_80182B84; + *(u32 *)(prim + 0x28) = D_80182B90; + *(u32 *)(prim + 0x2c) = D_80182B88; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_015/ov_SC06_015_jr_8015AE2C.c b/src/ov_SC06_015/ov_SC06_015_jr_8015AE2C.c index 5518afe2b..7a20e4591 100644 --- a/src/ov_SC06_015/ov_SC06_015_jr_8015AE2C.c +++ b/src/ov_SC06_015/ov_SC06_015_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_015/nonmatchings/ov_SC06_015_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801816BC[]; + extern u32 D_801816DC, D_801816E0, D_801816E4, D_801816E8; + extern u32 D_801816DC, D_801816E0, D_801816E4, D_801816E8; + extern u32 D_801816DC, D_801816E0, D_801816E4, D_801816E8; + extern u32 D_801816DC, D_801816E0, D_801816E4, D_801816E8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801816BC[0x00], p); + ApplyMatrixSV(mat, &D_801816BC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801816BC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801816BC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801816E4; + *(u32 *)(prim + 0x24) = D_801816DC; + *(u32 *)(prim + 0x28) = D_801816E8; + *(u32 *)(prim + 0x2c) = D_801816E0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8015AE2C.c b/src/ov_SC06_016/ov_SC06_016_jr_8015AE2C.c index e98f71578..2a5b9a13e 100644 --- a/src/ov_SC06_016/ov_SC06_016_jr_8015AE2C.c +++ b/src/ov_SC06_016/ov_SC06_016_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80187ACC[]; + extern u32 D_80187AEC, D_80187AF0, D_80187AF4, D_80187AF8; + extern u32 D_80187AEC, D_80187AF0, D_80187AF4, D_80187AF8; + extern u32 D_80187AEC, D_80187AF0, D_80187AF4, D_80187AF8; + extern u32 D_80187AEC, D_80187AF0, D_80187AF4, D_80187AF8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80187ACC[0x00], p); + ApplyMatrixSV(mat, &D_80187ACC[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80187ACC[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80187ACC[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80187AF4; + *(u32 *)(prim + 0x24) = D_80187AEC; + *(u32 *)(prim + 0x28) = D_80187AF8; + *(u32 *)(prim + 0x2c) = D_80187AF0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_018/ov_SC06_018_jr_8015AE2C.c b/src/ov_SC06_018/ov_SC06_018_jr_8015AE2C.c index 509b217b1..8916fe7e7 100644 --- a/src/ov_SC06_018/ov_SC06_018_jr_8015AE2C.c +++ b/src/ov_SC06_018/ov_SC06_018_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_018/nonmatchings/ov_SC06_018_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80196208[]; + extern u32 D_80196228, D_8019622C, D_80196230, D_80196234; + extern u32 D_80196228, D_8019622C, D_80196230, D_80196234; + extern u32 D_80196228, D_8019622C, D_80196230, D_80196234; + extern u32 D_80196228, D_8019622C, D_80196230, D_80196234; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80196208[0x00], p); + ApplyMatrixSV(mat, &D_80196208[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80196208[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80196208[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80196230; + *(u32 *)(prim + 0x24) = D_80196228; + *(u32 *)(prim + 0x28) = D_80196234; + *(u32 *)(prim + 0x2c) = D_8019622C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_020/ov_SC06_020_jr_8015AE2C.c b/src/ov_SC06_020/ov_SC06_020_jr_8015AE2C.c index ad2035225..f5adcce89 100644 --- a/src/ov_SC06_020/ov_SC06_020_jr_8015AE2C.c +++ b/src/ov_SC06_020/ov_SC06_020_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_020/nonmatchings/ov_SC06_020_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80187C90[]; + extern u32 D_80187CB0, D_80187CB4, D_80187CB8, D_80187CBC; + extern u32 D_80187CB0, D_80187CB4, D_80187CB8, D_80187CBC; + extern u32 D_80187CB0, D_80187CB4, D_80187CB8, D_80187CBC; + extern u32 D_80187CB0, D_80187CB4, D_80187CB8, D_80187CBC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80187C90[0x00], p); + ApplyMatrixSV(mat, &D_80187C90[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80187C90[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80187C90[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80187CB8; + *(u32 *)(prim + 0x24) = D_80187CB0; + *(u32 *)(prim + 0x28) = D_80187CBC; + *(u32 *)(prim + 0x2c) = D_80187CB4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_022/ov_SC06_022_jr_8015AE2C.c b/src/ov_SC06_022/ov_SC06_022_jr_8015AE2C.c index eae25dd34..5eff350e4 100644 --- a/src/ov_SC06_022/ov_SC06_022_jr_8015AE2C.c +++ b/src/ov_SC06_022/ov_SC06_022_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018FF4C[]; + extern u32 D_8018FF6C, D_8018FF70, D_8018FF74, D_8018FF78; + extern u32 D_8018FF6C, D_8018FF70, D_8018FF74, D_8018FF78; + extern u32 D_8018FF6C, D_8018FF70, D_8018FF74, D_8018FF78; + extern u32 D_8018FF6C, D_8018FF70, D_8018FF74, D_8018FF78; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018FF4C[0x00], p); + ApplyMatrixSV(mat, &D_8018FF4C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018FF4C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018FF4C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018FF74; + *(u32 *)(prim + 0x24) = D_8018FF6C; + *(u32 *)(prim + 0x28) = D_8018FF78; + *(u32 *)(prim + 0x2c) = D_8018FF70; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_024/ov_SC06_024_jr_8015AE2C.c b/src/ov_SC06_024/ov_SC06_024_jr_8015AE2C.c index 747de74c4..ba11aa480 100644 --- a/src/ov_SC06_024/ov_SC06_024_jr_8015AE2C.c +++ b/src/ov_SC06_024/ov_SC06_024_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80192424[]; + extern u32 D_80192444, D_80192448, D_8019244C, D_80192450; + extern u32 D_80192444, D_80192448, D_8019244C, D_80192450; + extern u32 D_80192444, D_80192448, D_8019244C, D_80192450; + extern u32 D_80192444, D_80192448, D_8019244C, D_80192450; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80192424[0x00], p); + ApplyMatrixSV(mat, &D_80192424[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80192424[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80192424[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8019244C; + *(u32 *)(prim + 0x24) = D_80192444; + *(u32 *)(prim + 0x28) = D_80192450; + *(u32 *)(prim + 0x2c) = D_80192448; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_025/ov_SC06_025_jr_8015AE2C.c b/src/ov_SC06_025/ov_SC06_025_jr_8015AE2C.c index 8b3452bdd..60f071156 100644 --- a/src/ov_SC06_025/ov_SC06_025_jr_8015AE2C.c +++ b/src/ov_SC06_025/ov_SC06_025_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801878C8[]; + extern u32 D_801878E8, D_801878EC, D_801878F0, D_801878F4; + extern u32 D_801878E8, D_801878EC, D_801878F0, D_801878F4; + extern u32 D_801878E8, D_801878EC, D_801878F0, D_801878F4; + extern u32 D_801878E8, D_801878EC, D_801878F0, D_801878F4; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801878C8[0x00], p); + ApplyMatrixSV(mat, &D_801878C8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801878C8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801878C8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801878F0; + *(u32 *)(prim + 0x24) = D_801878E8; + *(u32 *)(prim + 0x28) = D_801878F4; + *(u32 *)(prim + 0x2c) = D_801878EC; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_027/ov_SC06_027_jr_8015AE2C.c b/src/ov_SC06_027/ov_SC06_027_jr_8015AE2C.c index 8bef76b6e..c3e9060a1 100644 --- a/src/ov_SC06_027/ov_SC06_027_jr_8015AE2C.c +++ b/src/ov_SC06_027/ov_SC06_027_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_027/nonmatchings/ov_SC06_027_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80180C08[]; + extern u32 D_80180C28, D_80180C2C, D_80180C30, D_80180C34; + extern u32 D_80180C28, D_80180C2C, D_80180C30, D_80180C34; + extern u32 D_80180C28, D_80180C2C, D_80180C30, D_80180C34; + extern u32 D_80180C28, D_80180C2C, D_80180C30, D_80180C34; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80180C08[0x00], p); + ApplyMatrixSV(mat, &D_80180C08[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80180C08[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80180C08[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80180C30; + *(u32 *)(prim + 0x24) = D_80180C28; + *(u32 *)(prim + 0x28) = D_80180C34; + *(u32 *)(prim + 0x2c) = D_80180C2C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_029/ov_SC06_029_jr_8015AE2C.c b/src/ov_SC06_029/ov_SC06_029_jr_8015AE2C.c index 02d07fe8b..f68247b9b 100644 --- a/src/ov_SC06_029/ov_SC06_029_jr_8015AE2C.c +++ b/src/ov_SC06_029/ov_SC06_029_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018F19C[]; + extern u32 D_8018F1BC, D_8018F1C0, D_8018F1C4, D_8018F1C8; + extern u32 D_8018F1BC, D_8018F1C0, D_8018F1C4, D_8018F1C8; + extern u32 D_8018F1BC, D_8018F1C0, D_8018F1C4, D_8018F1C8; + extern u32 D_8018F1BC, D_8018F1C0, D_8018F1C4, D_8018F1C8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018F19C[0x00], p); + ApplyMatrixSV(mat, &D_8018F19C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018F19C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018F19C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018F1C4; + *(u32 *)(prim + 0x24) = D_8018F1BC; + *(u32 *)(prim + 0x28) = D_8018F1C8; + *(u32 *)(prim + 0x2c) = D_8018F1C0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_030/ov_SC06_030_jr_8015AE2C.c b/src/ov_SC06_030/ov_SC06_030_jr_8015AE2C.c index 68d96473b..a475bd1d4 100644 --- a/src/ov_SC06_030/ov_SC06_030_jr_8015AE2C.c +++ b/src/ov_SC06_030/ov_SC06_030_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_030/nonmatchings/ov_SC06_030_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80184A8C[]; + extern u32 D_80184AAC, D_80184AB0, D_80184AB4, D_80184AB8; + extern u32 D_80184AAC, D_80184AB0, D_80184AB4, D_80184AB8; + extern u32 D_80184AAC, D_80184AB0, D_80184AB4, D_80184AB8; + extern u32 D_80184AAC, D_80184AB0, D_80184AB4, D_80184AB8; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80184A8C[0x00], p); + ApplyMatrixSV(mat, &D_80184A8C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80184A8C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80184A8C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80184AB4; + *(u32 *)(prim + 0x24) = D_80184AAC; + *(u32 *)(prim + 0x28) = D_80184AB8; + *(u32 *)(prim + 0x2c) = D_80184AB0; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_032/ov_SC06_032_jr_8015AE2C.c b/src/ov_SC06_032/ov_SC06_032_jr_8015AE2C.c index 55314ef21..d40ef9f52 100644 --- a/src/ov_SC06_032/ov_SC06_032_jr_8015AE2C.c +++ b/src/ov_SC06_032/ov_SC06_032_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80195F58[]; + extern u32 D_80195F78, D_80195F7C, D_80195F80, D_80195F84; + extern u32 D_80195F78, D_80195F7C, D_80195F80, D_80195F84; + extern u32 D_80195F78, D_80195F7C, D_80195F80, D_80195F84; + extern u32 D_80195F78, D_80195F7C, D_80195F80, D_80195F84; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80195F58[0x00], p); + ApplyMatrixSV(mat, &D_80195F58[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80195F58[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80195F58[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80195F80; + *(u32 *)(prim + 0x24) = D_80195F78; + *(u32 *)(prim + 0x28) = D_80195F84; + *(u32 *)(prim + 0x2c) = D_80195F7C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC06_033/ov_SC06_033_jr_8015AE2C.c b/src/ov_SC06_033/ov_SC06_033_jr_8015AE2C.c index a131b96d4..5e2d0ccc4 100644 --- a/src/ov_SC06_033/ov_SC06_033_jr_8015AE2C.c +++ b/src/ov_SC06_033/ov_SC06_033_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80194468[]; + extern u32 D_80194488, D_8019448C, D_80194490, D_80194494; + extern u32 D_80194488, D_8019448C, D_80194490, D_80194494; + extern u32 D_80194488, D_8019448C, D_80194490, D_80194494; + extern u32 D_80194488, D_8019448C, D_80194490, D_80194494; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80194468[0x00], p); + ApplyMatrixSV(mat, &D_80194468[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80194468[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80194468[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80194490; + *(u32 *)(prim + 0x24) = D_80194488; + *(u32 *)(prim + 0x28) = D_80194494; + *(u32 *)(prim + 0x2c) = D_8019448C; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8015AE2C.c b/src/ov_SC07_000/ov_SC07_000_jr_8015AE2C.c index 5bb52041c..2cf2435f2 100644 --- a/src/ov_SC07_000/ov_SC07_000_jr_8015AE2C.c +++ b/src/ov_SC07_000/ov_SC07_000_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801852B0[]; + extern u32 D_801852D0, D_801852D4, D_801852D8, D_801852DC; + extern u32 D_801852D0, D_801852D4, D_801852D8, D_801852DC; + extern u32 D_801852D0, D_801852D4, D_801852D8, D_801852DC; + extern u32 D_801852D0, D_801852D4, D_801852D8, D_801852DC; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801852B0[0x00], p); + ApplyMatrixSV(mat, &D_801852B0[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801852B0[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801852B0[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801852D8; + *(u32 *)(prim + 0x24) = D_801852D0; + *(u32 *)(prim + 0x28) = D_801852DC; + *(u32 *)(prim + 0x2c) = D_801852D4; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC07_001/ov_SC07_001_jr_8015AE2C.c b/src/ov_SC07_001/ov_SC07_001_jr_8015AE2C.c index b711adf0a..e484ae73b 100644 --- a/src/ov_SC07_001/ov_SC07_001_jr_8015AE2C.c +++ b/src/ov_SC07_001/ov_SC07_001_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC07_001/nonmatchings/ov_SC07_001_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80184160[]; + extern u32 D_80184180, D_80184184, D_80184188, D_8018418C; + extern u32 D_80184180, D_80184184, D_80184188, D_8018418C; + extern u32 D_80184180, D_80184184, D_80184188, D_8018418C; + extern u32 D_80184180, D_80184184, D_80184188, D_8018418C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80184160[0x00], p); + ApplyMatrixSV(mat, &D_80184160[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80184160[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80184160[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80184188; + *(u32 *)(prim + 0x24) = D_80184180; + *(u32 *)(prim + 0x28) = D_8018418C; + *(u32 *)(prim + 0x2c) = D_80184184; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC07_002/ov_SC07_002_jr_8015AE2C.c b/src/ov_SC07_002/ov_SC07_002_jr_8015AE2C.c index 8ec95a25a..ccd00eddf 100644 --- a/src/ov_SC07_002/ov_SC07_002_jr_8015AE2C.c +++ b/src/ov_SC07_002/ov_SC07_002_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018941C[]; + extern u32 D_8018943C, D_80189440, D_80189444, D_80189448; + extern u32 D_8018943C, D_80189440, D_80189444, D_80189448; + extern u32 D_8018943C, D_80189440, D_80189444, D_80189448; + extern u32 D_8018943C, D_80189440, D_80189444, D_80189448; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018941C[0x00], p); + ApplyMatrixSV(mat, &D_8018941C[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018941C[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018941C[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80189444; + *(u32 *)(prim + 0x24) = D_8018943C; + *(u32 *)(prim + 0x28) = D_80189448; + *(u32 *)(prim + 0x2c) = D_80189440; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC07_006/ov_SC07_006_jr_8013F350.c b/src/ov_SC07_006/ov_SC07_006_jr_8013F350.c index 158b3174b..917e5e222 100644 --- a/src/ov_SC07_006/ov_SC07_006_jr_8013F350.c +++ b/src/ov_SC07_006/ov_SC07_006_jr_8013F350.c @@ -8833,7 +8833,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8013F350", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8018D040[]; + extern u32 D_8018D060, D_8018D064, D_8018D068, D_8018D06C; + extern u32 D_8018D060, D_8018D064, D_8018D068, D_8018D06C; + extern u32 D_8018D060, D_8018D064, D_8018D068, D_8018D06C; + extern u32 D_8018D060, D_8018D064, D_8018D068, D_8018D06C; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8018D040[0x00], p); + ApplyMatrixSV(mat, &D_8018D040[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8018D040[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8018D040[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8018D068; + *(u32 *)(prim + 0x24) = D_8018D060; + *(u32 *)(prim + 0x28) = D_8018D06C; + *(u32 *)(prim + 0x2c) = D_8018D064; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533c (src/shared) */ diff --git a/src/ov_SC07_007/ov_SC07_007_jr_8013F350.c b/src/ov_SC07_007/ov_SC07_007_jr_8013F350.c index 0c9ac6224..03eacb48b 100644 --- a/src/ov_SC07_007/ov_SC07_007_jr_8013F350.c +++ b/src/ov_SC07_007/ov_SC07_007_jr_8013F350.c @@ -8833,7 +8833,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8013F350", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80185B64[]; + extern u32 D_80185B84, D_80185B88, D_80185B8C, D_80185B90; + extern u32 D_80185B84, D_80185B88, D_80185B8C, D_80185B90; + extern u32 D_80185B84, D_80185B88, D_80185B8C, D_80185B90; + extern u32 D_80185B84, D_80185B88, D_80185B8C, D_80185B90; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80185B64[0x00], p); + ApplyMatrixSV(mat, &D_80185B64[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80185B64[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80185B64[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80185B8C; + *(u32 *)(prim + 0x24) = D_80185B84; + *(u32 *)(prim + 0x28) = D_80185B90; + *(u32 *)(prim + 0x2c) = D_80185B88; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533c (src/shared) */ diff --git a/src/ov_SC07_008/ov_SC07_008_jr_8015AE2C.c b/src/ov_SC07_008/ov_SC07_008_jr_8015AE2C.c index 452cd9b7a..98f1ee906 100644 --- a/src/ov_SC07_008/ov_SC07_008_jr_8015AE2C.c +++ b/src/ov_SC07_008/ov_SC07_008_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC07_008/nonmatchings/ov_SC07_008_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_8017FF34[]; + extern u32 D_8017FF54, D_8017FF58, D_8017FF5C, D_8017FF60; + extern u32 D_8017FF54, D_8017FF58, D_8017FF5C, D_8017FF60; + extern u32 D_8017FF54, D_8017FF58, D_8017FF5C, D_8017FF60; + extern u32 D_8017FF54, D_8017FF58, D_8017FF5C, D_8017FF60; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_8017FF34[0x00], p); + ApplyMatrixSV(mat, &D_8017FF34[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_8017FF34[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_8017FF34[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_8017FF5C; + *(u32 *)(prim + 0x24) = D_8017FF54; + *(u32 *)(prim + 0x28) = D_8017FF60; + *(u32 *)(prim + 0x2c) = D_8017FF58; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC07_009/ov_SC07_009_jr_8015AE2C.c b/src/ov_SC07_009/ov_SC07_009_jr_8015AE2C.c index 4ac75fbff..985eae1e6 100644 --- a/src/ov_SC07_009/ov_SC07_009_jr_8015AE2C.c +++ b/src/ov_SC07_009/ov_SC07_009_jr_8015AE2C.c @@ -4463,7 +4463,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC07_009/nonmatchings/ov_SC07_009_jr_8015AE2C", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801809D8[]; + extern u32 D_801809F8, D_801809FC, D_80180A00, D_80180A04; + extern u32 D_801809F8, D_801809FC, D_80180A00, D_80180A04; + extern u32 D_801809F8, D_801809FC, D_80180A00, D_80180A04; + extern u32 D_801809F8, D_801809FC, D_80180A00, D_80180A04; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801809D8[0x00], p); + ApplyMatrixSV(mat, &D_801809D8[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801809D8[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801809D8[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80180A00; + *(u32 *)(prim + 0x24) = D_801809F8; + *(u32 *)(prim + 0x28) = D_80180A04; + *(u32 *)(prim + 0x2c) = D_801809FC; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533C (src/shared) */ diff --git a/src/ov_SC07_010/ov_SC07_010_o2b.c b/src/ov_SC07_010/ov_SC07_010_o2b.c index a10c606a7..40f843975 100644 --- a/src/ov_SC07_010/ov_SC07_010_o2b.c +++ b/src/ov_SC07_010/ov_SC07_010_o2b.c @@ -9479,7 +9479,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_o2b", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_80184BF4[]; + extern u32 D_80184C14, D_80184C18, D_80184C1C, D_80184C20; + extern u32 D_80184C14, D_80184C18, D_80184C1C, D_80184C20; + extern u32 D_80184C14, D_80184C18, D_80184C1C, D_80184C20; + extern u32 D_80184C14, D_80184C18, D_80184C1C, D_80184C20; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_80184BF4[0x00], p); + ApplyMatrixSV(mat, &D_80184BF4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_80184BF4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_80184BF4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_80184C1C; + *(u32 *)(prim + 0x24) = D_80184C14; + *(u32 *)(prim + 0x28) = D_80184C20; + *(u32 *)(prim + 0x2c) = D_80184C18; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533c (src/shared) */ diff --git a/src/ov_SC07_011/ov_SC07_011_jr_8013F350.c b/src/ov_SC07_011/ov_SC07_011_jr_8013F350.c index b44081cef..ad9075103 100644 --- a/src/ov_SC07_011/ov_SC07_011_jr_8013F350.c +++ b/src/ov_SC07_011/ov_SC07_011_jr_8013F350.c @@ -8829,7 +8829,40 @@ void func_801651B8(void * param_1) } -INCLUDE_ASM("asm/ov_SC07_011/nonmatchings/ov_SC07_011_jr_8013F350", func_80165240); +struct W4 { u32 w; } __attribute__((packed, aligned(1))); +extern void func_80016ED4(void *a0); +extern s32 func_80017DC4(void *a0, void *a1); + +void func_80165240(void *param_1, void *param_2, void *param_3) +{ + + extern u8 D_801812B4[]; + extern u32 D_801812D4, D_801812D8, D_801812DC, D_801812E0; + extern u32 D_801812D4, D_801812D8, D_801812DC, D_801812E0; + extern u32 D_801812D4, D_801812D8, D_801812DC, D_801812E0; + extern u32 D_801812D4, D_801812D8, D_801812DC, D_801812E0; + u8 prim[0x40]; /* $sp+0x10 .. 0x50 */ + u8 mat[0x20]; /* $sp+0x50 .. 0x70 */ + u8 *p = prim; + + func_80017DC4(param_2, mat); + ApplyMatrixSV(mat, &D_801812B4[0x00], p); + ApplyMatrixSV(mat, &D_801812B4[0x08], prim + 0x08); + ApplyMatrixSV(mat, &D_801812B4[0x10], prim + 0x10); + ApplyMatrixSV(mat, &D_801812B4[0x18], prim + 0x18); + + *(s16 *)(prim + 0x04) = 3; + prim[0x38] = 0x2c; + *(u32 *)(prim + 0x20) = D_801812DC; + *(u32 *)(prim + 0x24) = D_801812D4; + *(u32 *)(prim + 0x28) = D_801812E0; + *(u32 *)(prim + 0x2c) = D_801812D8; + *(struct W4 *)(prim + 0x30) = *(struct W4 *)param_3; + *(u32 *)(prim + 0x34) = 0x50000000; + + func_80016ED4(p); +} + DEFINE_func_8016533C() /* dedup: shared engine-core @0x8016533c (src/shared) */