From 6b0bb5440a99ab057cc96079b0a6bde9fa827e1e Mon Sep 17 00:00:00 2001 From: Drew T <50529377+Druthulu@users.noreply.github.com> Date: Sat, 18 Jul 2026 20:05:42 -0600 Subject: [PATCH] feat(phase-29 broad-sweep): +137 (func_801502EC x134 + func_80131B14 x3) via --fix-def-sig MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - broad --fix-def-sig sweep across the 60 substantial matched-ov077 families: 137/2169 banked. - HONEST FRONTIER FINDING (R14/R35): the substantial-family pool is NOT broadly mechanical — only 137 of 2169 STAGED drafts actually bank; staging != banking. I over-estimated yield from the staged count instead of gate-probing a sample first (the phase's own invariant). The other ~2032 need per-family levers (self-decl / type-lift / def-sig+caller-thread), not one broad pass. - --normalize-self-decls is SURGICAL-ONLY: applied broadly (esp. with --fix-def-sig) it makes non-neutral TU edits that poison whole (overlay,split) groups; the backstop reverts them (0 false banks) but it yields ~0. --fix-def-sig is broad-safe (draft-level, bisects per-member). - R22 clean-fleet 140/140 byte-identical; tools-health OK (dedup unchanged); 0 NON_MATCHING (G4). --- src/ov_SC01_000/ov_SC01_000_after.c | 42 ++++++++++++- src/ov_SC01_001/ov_SC01_001_after.c | 42 ++++++++++++- src/ov_SC01_004/ov_SC01_004_after.c | 42 ++++++++++++- src/ov_SC01_005/ov_SC01_005_after.c | 42 ++++++++++++- src/ov_SC01_006/ov_SC01_006_after.c | 42 ++++++++++++- src/ov_SC01_008/ov_SC01_008_after.c | 42 ++++++++++++- src/ov_SC01_009/ov_SC01_009_after.c | 42 ++++++++++++- src/ov_SC01_074/ov_SC01_074_after.c | 42 ++++++++++++- src/ov_SC01_080/ov_SC01_080_after.c | 42 ++++++++++++- src/ov_SC01_084/ov_SC01_084_after.c | 42 ++++++++++++- src/ov_SC02_000/ov_SC02_000_after.c | 42 ++++++++++++- src/ov_SC02_003/ov_SC02_003_after.c | 42 ++++++++++++- src/ov_SC02_004/ov_SC02_004_after.c | 42 ++++++++++++- src/ov_SC02_005/ov_SC02_005_after.c | 42 ++++++++++++- src/ov_SC02_011/ov_SC02_011_after.c | 42 ++++++++++++- src/ov_SC02_015/ov_SC02_015_after.c | 42 ++++++++++++- src/ov_SC02_016/ov_SC02_016_after.c | 42 ++++++++++++- src/ov_SC02_017/ov_SC02_017_after.c | 42 ++++++++++++- src/ov_SC02_021/ov_SC02_021_after.c | 42 ++++++++++++- src/ov_SC02_026/ov_SC02_026_after.c | 42 ++++++++++++- src/ov_SC02_027/ov_SC02_027_after.c | 42 ++++++++++++- src/ov_SC02_028/ov_SC02_028_after.c | 42 ++++++++++++- src/ov_SC02_031/ov_SC02_031_after.c | 42 ++++++++++++- src/ov_SC02_035/ov_SC02_035_after.c | 42 ++++++++++++- src/ov_SC02_039/ov_SC02_039_after.c | 42 ++++++++++++- src/ov_SC02_041/ov_SC02_041_after.c | 42 ++++++++++++- src/ov_SC03_001/ov_SC03_001_after.c | 42 ++++++++++++- src/ov_SC03_002/ov_SC03_002_after.c | 42 ++++++++++++- src/ov_SC03_003/ov_SC03_003_after.c | 42 ++++++++++++- src/ov_SC03_006/ov_SC03_006_after.c | 42 ++++++++++++- src/ov_SC03_007/ov_SC03_007_after.c | 42 ++++++++++++- src/ov_SC03_010/ov_SC03_010_after.c | 42 ++++++++++++- src/ov_SC03_011/ov_SC03_011_after.c | 42 ++++++++++++- src/ov_SC03_012/ov_SC03_012_after.c | 42 ++++++++++++- src/ov_SC03_013/ov_SC03_013_after.c | 42 ++++++++++++- src/ov_SC03_014/ov_SC03_014_after.c | 42 ++++++++++++- src/ov_SC03_015/ov_SC03_015_after.c | 42 ++++++++++++- src/ov_SC03_023/ov_SC03_023_after.c | 42 ++++++++++++- src/ov_SC03_024/ov_SC03_024_after.c | 42 ++++++++++++- src/ov_SC03_028/ov_SC03_028_after.c | 42 ++++++++++++- src/ov_SC03_029/ov_SC03_029_after.c | 42 ++++++++++++- src/ov_SC03_030/ov_SC03_030_after.c | 42 ++++++++++++- src/ov_SC03_031/ov_SC03_031_after.c | 42 ++++++++++++- src/ov_SC03_089/ov_SC03_089_after.c | 42 ++++++++++++- src/ov_SC03_090/ov_SC03_090_after.c | 42 ++++++++++++- src/ov_SC03_091/ov_SC03_091_after.c | 42 ++++++++++++- src/ov_SC03_092/ov_SC03_092_after.c | 42 ++++++++++++- src/ov_SC03_093/ov_SC03_093_after.c | 42 ++++++++++++- src/ov_SC03_094/ov_SC03_094_after.c | 42 ++++++++++++- src/ov_SC03_095/ov_SC03_095_after.c | 42 ++++++++++++- src/ov_SC03_096/ov_SC03_096_after.c | 42 ++++++++++++- src/ov_SC03_097/ov_SC03_097_after.c | 42 ++++++++++++- src/ov_SC03_098/ov_SC03_098_after.c | 42 ++++++++++++- src/ov_SC03_099/ov_SC03_099_after.c | 42 ++++++++++++- src/ov_SC03_100/ov_SC03_100_after.c | 42 ++++++++++++- src/ov_SC03_101/ov_SC03_101_after.c | 42 ++++++++++++- src/ov_SC03_102/ov_SC03_102_after.c | 42 ++++++++++++- src/ov_SC03_103/ov_SC03_103_after.c | 42 ++++++++++++- src/ov_SC03_104/ov_SC03_104_after.c | 42 ++++++++++++- src/ov_SC03_105/ov_SC03_105_after.c | 42 ++++++++++++- src/ov_SC03_108/ov_SC03_108_after.c | 42 ++++++++++++- src/ov_SC03_109/ov_SC03_109_after.c | 42 ++++++++++++- src/ov_SC03_110/ov_SC03_110_after.c | 42 ++++++++++++- src/ov_SC03_111/ov_SC03_111_after.c | 42 ++++++++++++- src/ov_SC03_112/ov_SC03_112_after.c | 42 ++++++++++++- src/ov_SC03_113/ov_SC03_113_after.c | 42 ++++++++++++- src/ov_SC03_114/ov_SC03_114_after.c | 42 ++++++++++++- src/ov_SC03_115/ov_SC03_115_after.c | 42 ++++++++++++- src/ov_SC03_116/ov_SC03_116_after.c | 42 ++++++++++++- src/ov_SC03_117/ov_SC03_117_after.c | 42 ++++++++++++- src/ov_SC03_118/ov_SC03_118_after.c | 42 ++++++++++++- src/ov_SC03_119/ov_SC03_119_after.c | 42 ++++++++++++- src/ov_SC03_121/ov_SC03_121_after.c | 42 ++++++++++++- src/ov_SC03_124/ov_SC03_124_after.c | 42 ++++++++++++- src/ov_SC03_125/ov_SC03_125_after.c | 42 ++++++++++++- src/ov_SC03_126/ov_SC03_126_after.c | 42 ++++++++++++- src/ov_SC04_000/ov_SC04_000_after.c | 42 ++++++++++++- src/ov_SC04_002/ov_SC04_002_after.c | 42 ++++++++++++- src/ov_SC04_003/ov_SC04_003_after.c | 42 ++++++++++++- src/ov_SC04_004/ov_SC04_004_after.c | 42 ++++++++++++- src/ov_SC04_005/ov_SC04_005_after.c | 42 ++++++++++++- src/ov_SC04_006/ov_SC04_006_after.c | 42 ++++++++++++- src/ov_SC04_007/ov_SC04_007_after.c | 42 ++++++++++++- src/ov_SC04_008/ov_SC04_008_after.c | 42 ++++++++++++- src/ov_SC04_009/ov_SC04_009_after.c | 42 ++++++++++++- src/ov_SC04_010/ov_SC04_010_after.c | 42 ++++++++++++- src/ov_SC04_011/ov_SC04_011_after.c | 42 ++++++++++++- src/ov_SC04_012/ov_SC04_012_after.c | 42 ++++++++++++- src/ov_SC04_015/ov_SC04_015_after.c | 42 ++++++++++++- src/ov_SC04_016/ov_SC04_016_after.c | 42 ++++++++++++- src/ov_SC04_018/ov_SC04_018_after.c | 42 ++++++++++++- src/ov_SC04_019/ov_SC04_019_after.c | 42 ++++++++++++- src/ov_SC04_020/ov_SC04_020_after.c | 42 ++++++++++++- src/ov_SC04_021/ov_SC04_021_after.c | 42 ++++++++++++- src/ov_SC05_000/ov_SC05_000_after.c | 42 ++++++++++++- src/ov_SC05_001/ov_SC05_001_after.c | 42 ++++++++++++- src/ov_SC05_002/ov_SC05_002_after.c | 42 ++++++++++++- src/ov_SC05_003/ov_SC05_003_after.c | 42 ++++++++++++- src/ov_SC05_004/ov_SC05_004_after.c | 42 ++++++++++++- src/ov_SC05_005/ov_SC05_005_after.c | 42 ++++++++++++- src/ov_SC05_006/ov_SC05_006_after.c | 42 ++++++++++++- src/ov_SC05_007/ov_SC05_007_after.c | 42 ++++++++++++- src/ov_SC05_008/ov_SC05_008_after.c | 42 ++++++++++++- src/ov_SC05_009/ov_SC05_009_after.c | 42 ++++++++++++- src/ov_SC05_010/ov_SC05_010_after.c | 42 ++++++++++++- src/ov_SC05_011/ov_SC05_011_after.c | 42 ++++++++++++- src/ov_SC05_017/ov_SC05_017_after.c | 42 ++++++++++++- src/ov_SC05_018/ov_SC05_018_after.c | 42 ++++++++++++- src/ov_SC05_019/ov_SC05_019_after.c | 42 ++++++++++++- src/ov_SC06_000/ov_SC06_000_after.c | 42 ++++++++++++- src/ov_SC06_006/ov_SC06_006_after.c | 42 ++++++++++++- src/ov_SC06_008/ov_SC06_008_after.c | 42 ++++++++++++- src/ov_SC06_010/ov_SC06_010_after.c | 42 ++++++++++++- src/ov_SC06_011/ov_SC06_011_after.c | 42 ++++++++++++- src/ov_SC06_013/ov_SC06_013_after.c | 42 ++++++++++++- src/ov_SC06_014/ov_SC06_014_after.c | 42 ++++++++++++- src/ov_SC06_015/ov_SC06_015_after.c | 42 ++++++++++++- src/ov_SC06_016/ov_SC06_016_after.c | 42 ++++++++++++- src/ov_SC06_018/ov_SC06_018_after.c | 42 ++++++++++++- src/ov_SC06_020/ov_SC06_020_after.c | 42 ++++++++++++- src/ov_SC06_022/ov_SC06_022_after.c | 42 ++++++++++++- src/ov_SC06_024/ov_SC06_024_after.c | 42 ++++++++++++- src/ov_SC06_025/ov_SC06_025_after.c | 42 ++++++++++++- src/ov_SC06_027/ov_SC06_027_after.c | 42 ++++++++++++- src/ov_SC06_029/ov_SC06_029_after.c | 42 ++++++++++++- src/ov_SC06_030/ov_SC06_030_after.c | 42 ++++++++++++- src/ov_SC06_032/ov_SC06_032_after.c | 42 ++++++++++++- src/ov_SC06_033/ov_SC06_033_after.c | 42 ++++++++++++- src/ov_SC07_000/ov_SC07_000_after.c | 42 ++++++++++++- src/ov_SC07_001/ov_SC07_001_after.c | 42 ++++++++++++- src/ov_SC07_002/ov_SC07_002_after.c | 42 ++++++++++++- src/ov_SC07_006/ov_SC07_006_jr_80131340.c | 73 ++++++++++++++++++++++- src/ov_SC07_007/ov_SC07_007_jr_80131340.c | 73 ++++++++++++++++++++++- src/ov_SC07_008/ov_SC07_008_after.c | 42 ++++++++++++- src/ov_SC07_009/ov_SC07_009_after.c | 42 ++++++++++++- src/ov_SC07_010/ov_SC07_010_o2b.c | 42 ++++++++++++- src/ov_SC07_011/ov_SC07_011_jr_80131340.c | 73 ++++++++++++++++++++++- 137 files changed, 5710 insertions(+), 137 deletions(-) diff --git a/src/ov_SC01_000/ov_SC01_000_after.c b/src/ov_SC01_000/ov_SC01_000_after.c index d2e44753f..6ee5bf65f 100644 --- a/src/ov_SC01_000/ov_SC01_000_after.c +++ b/src/ov_SC01_000/ov_SC01_000_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC01_001/ov_SC01_001_after.c b/src/ov_SC01_001/ov_SC01_001_after.c index 2cb7b8573..4a521fe49 100644 --- a/src/ov_SC01_001/ov_SC01_001_after.c +++ b/src/ov_SC01_001/ov_SC01_001_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC01_004/ov_SC01_004_after.c b/src/ov_SC01_004/ov_SC01_004_after.c index 9c662894e..1242e4c2f 100644 --- a/src/ov_SC01_004/ov_SC01_004_after.c +++ b/src/ov_SC01_004/ov_SC01_004_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_004/nonmatchings/ov_SC01_004_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_004/nonmatchings/ov_SC01_004_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC01_005/ov_SC01_005_after.c b/src/ov_SC01_005/ov_SC01_005_after.c index 72288e681..4d494f46e 100644 --- a/src/ov_SC01_005/ov_SC01_005_after.c +++ b/src/ov_SC01_005/ov_SC01_005_after.c @@ -1927,7 +1927,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC01_006/ov_SC01_006_after.c b/src/ov_SC01_006/ov_SC01_006_after.c index 04d072ec1..d51e1fdce 100644 --- a/src/ov_SC01_006/ov_SC01_006_after.c +++ b/src/ov_SC01_006/ov_SC01_006_after.c @@ -1927,7 +1927,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC01_008/ov_SC01_008_after.c b/src/ov_SC01_008/ov_SC01_008_after.c index 63cb1fa24..c5d765180 100644 --- a/src/ov_SC01_008/ov_SC01_008_after.c +++ b/src/ov_SC01_008/ov_SC01_008_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_008/nonmatchings/ov_SC01_008_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_008/nonmatchings/ov_SC01_008_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC01_009/ov_SC01_009_after.c b/src/ov_SC01_009/ov_SC01_009_after.c index 7a85e868a..bb30926cf 100644 --- a/src/ov_SC01_009/ov_SC01_009_after.c +++ b/src/ov_SC01_009/ov_SC01_009_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC01_074/ov_SC01_074_after.c b/src/ov_SC01_074/ov_SC01_074_after.c index 29ccfde02..1212b88e2 100644 --- a/src/ov_SC01_074/ov_SC01_074_after.c +++ b/src/ov_SC01_074/ov_SC01_074_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC01_080/ov_SC01_080_after.c b/src/ov_SC01_080/ov_SC01_080_after.c index c20163063..c55cb7cc6 100644 --- a/src/ov_SC01_080/ov_SC01_080_after.c +++ b/src/ov_SC01_080/ov_SC01_080_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC01_084/ov_SC01_084_after.c b/src/ov_SC01_084/ov_SC01_084_after.c index cdf53292f..d6330cd67 100644 --- a/src/ov_SC01_084/ov_SC01_084_after.c +++ b/src/ov_SC01_084/ov_SC01_084_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_after", func_80150170); -INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_000/ov_SC02_000_after.c b/src/ov_SC02_000/ov_SC02_000_after.c index 542e19ddc..36bfdf8ab 100644 --- a/src/ov_SC02_000/ov_SC02_000_after.c +++ b/src/ov_SC02_000/ov_SC02_000_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_003/ov_SC02_003_after.c b/src/ov_SC02_003/ov_SC02_003_after.c index cfc51a32b..74ea8dd3d 100644 --- a/src/ov_SC02_003/ov_SC02_003_after.c +++ b/src/ov_SC02_003/ov_SC02_003_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_003/nonmatchings/ov_SC02_003_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_003/nonmatchings/ov_SC02_003_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_004/ov_SC02_004_after.c b/src/ov_SC02_004/ov_SC02_004_after.c index 4b48efb30..90726163c 100644 --- a/src/ov_SC02_004/ov_SC02_004_after.c +++ b/src/ov_SC02_004/ov_SC02_004_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_004/nonmatchings/ov_SC02_004_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_004/nonmatchings/ov_SC02_004_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_005/ov_SC02_005_after.c b/src/ov_SC02_005/ov_SC02_005_after.c index 3dcd21e53..73fc0a2f9 100644 --- a/src/ov_SC02_005/ov_SC02_005_after.c +++ b/src/ov_SC02_005/ov_SC02_005_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_011/ov_SC02_011_after.c b/src/ov_SC02_011/ov_SC02_011_after.c index d77c9a0e8..970321400 100644 --- a/src/ov_SC02_011/ov_SC02_011_after.c +++ b/src/ov_SC02_011/ov_SC02_011_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_015/ov_SC02_015_after.c b/src/ov_SC02_015/ov_SC02_015_after.c index 58959258c..15ab7b3a7 100644 --- a/src/ov_SC02_015/ov_SC02_015_after.c +++ b/src/ov_SC02_015/ov_SC02_015_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_015/nonmatchings/ov_SC02_015_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_015/nonmatchings/ov_SC02_015_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_016/ov_SC02_016_after.c b/src/ov_SC02_016/ov_SC02_016_after.c index 14b08e615..acc4973e5 100644 --- a/src/ov_SC02_016/ov_SC02_016_after.c +++ b/src/ov_SC02_016/ov_SC02_016_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_017/ov_SC02_017_after.c b/src/ov_SC02_017/ov_SC02_017_after.c index 5d04be75b..4f27bb62c 100644 --- a/src/ov_SC02_017/ov_SC02_017_after.c +++ b/src/ov_SC02_017/ov_SC02_017_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_021/ov_SC02_021_after.c b/src/ov_SC02_021/ov_SC02_021_after.c index efbd47297..d988de7fb 100644 --- a/src/ov_SC02_021/ov_SC02_021_after.c +++ b/src/ov_SC02_021/ov_SC02_021_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_026/ov_SC02_026_after.c b/src/ov_SC02_026/ov_SC02_026_after.c index 0aec0ff4c..19544491e 100644 --- a/src/ov_SC02_026/ov_SC02_026_after.c +++ b/src/ov_SC02_026/ov_SC02_026_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_026/nonmatchings/ov_SC02_026_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_026/nonmatchings/ov_SC02_026_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_027/ov_SC02_027_after.c b/src/ov_SC02_027/ov_SC02_027_after.c index e8341e4ab..eb900e763 100644 --- a/src/ov_SC02_027/ov_SC02_027_after.c +++ b/src/ov_SC02_027/ov_SC02_027_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_028/ov_SC02_028_after.c b/src/ov_SC02_028/ov_SC02_028_after.c index 37dedc32c..a3fad5be2 100644 --- a/src/ov_SC02_028/ov_SC02_028_after.c +++ b/src/ov_SC02_028/ov_SC02_028_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_031/ov_SC02_031_after.c b/src/ov_SC02_031/ov_SC02_031_after.c index f4458fd3d..80f072f9c 100644 --- a/src/ov_SC02_031/ov_SC02_031_after.c +++ b/src/ov_SC02_031/ov_SC02_031_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_031/nonmatchings/ov_SC02_031_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_031/nonmatchings/ov_SC02_031_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_035/ov_SC02_035_after.c b/src/ov_SC02_035/ov_SC02_035_after.c index a8eb02bcd..f39c855a5 100644 --- a/src/ov_SC02_035/ov_SC02_035_after.c +++ b/src/ov_SC02_035/ov_SC02_035_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_035/nonmatchings/ov_SC02_035_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_035/nonmatchings/ov_SC02_035_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_039/ov_SC02_039_after.c b/src/ov_SC02_039/ov_SC02_039_after.c index a52dc7051..858f1750c 100644 --- a/src/ov_SC02_039/ov_SC02_039_after.c +++ b/src/ov_SC02_039/ov_SC02_039_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_039/nonmatchings/ov_SC02_039_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_039/nonmatchings/ov_SC02_039_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC02_041/ov_SC02_041_after.c b/src/ov_SC02_041/ov_SC02_041_after.c index 665203c50..e4346c060 100644 --- a/src/ov_SC02_041/ov_SC02_041_after.c +++ b/src/ov_SC02_041/ov_SC02_041_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC02_041/nonmatchings/ov_SC02_041_after", func_80150170); -INCLUDE_ASM("asm/ov_SC02_041/nonmatchings/ov_SC02_041_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_001/ov_SC03_001_after.c b/src/ov_SC03_001/ov_SC03_001_after.c index 911f3a8eb..1269ace31 100644 --- a/src/ov_SC03_001/ov_SC03_001_after.c +++ b/src/ov_SC03_001/ov_SC03_001_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_001/nonmatchings/ov_SC03_001_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_001/nonmatchings/ov_SC03_001_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_002/ov_SC03_002_after.c b/src/ov_SC03_002/ov_SC03_002_after.c index 63ddc5a35..7f38dd6b8 100644 --- a/src/ov_SC03_002/ov_SC03_002_after.c +++ b/src/ov_SC03_002/ov_SC03_002_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_002/nonmatchings/ov_SC03_002_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_002/nonmatchings/ov_SC03_002_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_003/ov_SC03_003_after.c b/src/ov_SC03_003/ov_SC03_003_after.c index 0f5bbf29b..35c3904ef 100644 --- a/src/ov_SC03_003/ov_SC03_003_after.c +++ b/src/ov_SC03_003/ov_SC03_003_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_003/nonmatchings/ov_SC03_003_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_003/nonmatchings/ov_SC03_003_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_006/ov_SC03_006_after.c b/src/ov_SC03_006/ov_SC03_006_after.c index 4e161b897..597a4035e 100644 --- a/src/ov_SC03_006/ov_SC03_006_after.c +++ b/src/ov_SC03_006/ov_SC03_006_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_007/ov_SC03_007_after.c b/src/ov_SC03_007/ov_SC03_007_after.c index e7435299c..3974b3093 100644 --- a/src/ov_SC03_007/ov_SC03_007_after.c +++ b/src/ov_SC03_007/ov_SC03_007_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_010/ov_SC03_010_after.c b/src/ov_SC03_010/ov_SC03_010_after.c index e2ad161c8..9ec70ddde 100644 --- a/src/ov_SC03_010/ov_SC03_010_after.c +++ b/src/ov_SC03_010/ov_SC03_010_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_010/nonmatchings/ov_SC03_010_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_010/nonmatchings/ov_SC03_010_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_011/ov_SC03_011_after.c b/src/ov_SC03_011/ov_SC03_011_after.c index be1f43309..46b64e21f 100644 --- a/src/ov_SC03_011/ov_SC03_011_after.c +++ b/src/ov_SC03_011/ov_SC03_011_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_012/ov_SC03_012_after.c b/src/ov_SC03_012/ov_SC03_012_after.c index 7d7f371dd..1426174ca 100644 --- a/src/ov_SC03_012/ov_SC03_012_after.c +++ b/src/ov_SC03_012/ov_SC03_012_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_012/nonmatchings/ov_SC03_012_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_012/nonmatchings/ov_SC03_012_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_013/ov_SC03_013_after.c b/src/ov_SC03_013/ov_SC03_013_after.c index f4c8899e6..b1e4629a2 100644 --- a/src/ov_SC03_013/ov_SC03_013_after.c +++ b/src/ov_SC03_013/ov_SC03_013_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_013/nonmatchings/ov_SC03_013_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_013/nonmatchings/ov_SC03_013_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_014/ov_SC03_014_after.c b/src/ov_SC03_014/ov_SC03_014_after.c index 556eafb0f..ea8c28766 100644 --- a/src/ov_SC03_014/ov_SC03_014_after.c +++ b/src/ov_SC03_014/ov_SC03_014_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_014/nonmatchings/ov_SC03_014_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_014/nonmatchings/ov_SC03_014_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_015/ov_SC03_015_after.c b/src/ov_SC03_015/ov_SC03_015_after.c index 9a4afb127..c49c9fa4d 100644 --- a/src/ov_SC03_015/ov_SC03_015_after.c +++ b/src/ov_SC03_015/ov_SC03_015_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_023/ov_SC03_023_after.c b/src/ov_SC03_023/ov_SC03_023_after.c index dca8b0763..9320e3856 100644 --- a/src/ov_SC03_023/ov_SC03_023_after.c +++ b/src/ov_SC03_023/ov_SC03_023_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_024/ov_SC03_024_after.c b/src/ov_SC03_024/ov_SC03_024_after.c index f5b150b54..a5463aada 100644 --- a/src/ov_SC03_024/ov_SC03_024_after.c +++ b/src/ov_SC03_024/ov_SC03_024_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_024/nonmatchings/ov_SC03_024_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_024/nonmatchings/ov_SC03_024_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_028/ov_SC03_028_after.c b/src/ov_SC03_028/ov_SC03_028_after.c index eb621c75f..417bd94bc 100644 --- a/src/ov_SC03_028/ov_SC03_028_after.c +++ b/src/ov_SC03_028/ov_SC03_028_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_029/ov_SC03_029_after.c b/src/ov_SC03_029/ov_SC03_029_after.c index 831067a7b..f021d8577 100644 --- a/src/ov_SC03_029/ov_SC03_029_after.c +++ b/src/ov_SC03_029/ov_SC03_029_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_030/ov_SC03_030_after.c b/src/ov_SC03_030/ov_SC03_030_after.c index 4d686e619..fea408c16 100644 --- a/src/ov_SC03_030/ov_SC03_030_after.c +++ b/src/ov_SC03_030/ov_SC03_030_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_030/nonmatchings/ov_SC03_030_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_030/nonmatchings/ov_SC03_030_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_031/ov_SC03_031_after.c b/src/ov_SC03_031/ov_SC03_031_after.c index 7429803cc..d94de2b68 100644 --- a/src/ov_SC03_031/ov_SC03_031_after.c +++ b/src/ov_SC03_031/ov_SC03_031_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_089/ov_SC03_089_after.c b/src/ov_SC03_089/ov_SC03_089_after.c index 0bbd8dbed..76e5ca0a1 100644 --- a/src/ov_SC03_089/ov_SC03_089_after.c +++ b/src/ov_SC03_089/ov_SC03_089_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_089/nonmatchings/ov_SC03_089_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_089/nonmatchings/ov_SC03_089_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_090/ov_SC03_090_after.c b/src/ov_SC03_090/ov_SC03_090_after.c index fbda74b43..d82eaf10b 100644 --- a/src/ov_SC03_090/ov_SC03_090_after.c +++ b/src/ov_SC03_090/ov_SC03_090_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_091/ov_SC03_091_after.c b/src/ov_SC03_091/ov_SC03_091_after.c index ef1e5184a..f9ffaddf0 100644 --- a/src/ov_SC03_091/ov_SC03_091_after.c +++ b/src/ov_SC03_091/ov_SC03_091_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_091/nonmatchings/ov_SC03_091_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_091/nonmatchings/ov_SC03_091_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_092/ov_SC03_092_after.c b/src/ov_SC03_092/ov_SC03_092_after.c index 69560ae55..bb9285aad 100644 --- a/src/ov_SC03_092/ov_SC03_092_after.c +++ b/src/ov_SC03_092/ov_SC03_092_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_092/nonmatchings/ov_SC03_092_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_092/nonmatchings/ov_SC03_092_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_093/ov_SC03_093_after.c b/src/ov_SC03_093/ov_SC03_093_after.c index 49b170eee..db755c093 100644 --- a/src/ov_SC03_093/ov_SC03_093_after.c +++ b/src/ov_SC03_093/ov_SC03_093_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_093/nonmatchings/ov_SC03_093_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_093/nonmatchings/ov_SC03_093_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_094/ov_SC03_094_after.c b/src/ov_SC03_094/ov_SC03_094_after.c index ea75726c4..351690f98 100644 --- a/src/ov_SC03_094/ov_SC03_094_after.c +++ b/src/ov_SC03_094/ov_SC03_094_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_094/nonmatchings/ov_SC03_094_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_094/nonmatchings/ov_SC03_094_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_095/ov_SC03_095_after.c b/src/ov_SC03_095/ov_SC03_095_after.c index 4f439c260..518f02aa0 100644 --- a/src/ov_SC03_095/ov_SC03_095_after.c +++ b/src/ov_SC03_095/ov_SC03_095_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_095/nonmatchings/ov_SC03_095_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_095/nonmatchings/ov_SC03_095_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_096/ov_SC03_096_after.c b/src/ov_SC03_096/ov_SC03_096_after.c index 8dad605a9..9767b5bb2 100644 --- a/src/ov_SC03_096/ov_SC03_096_after.c +++ b/src/ov_SC03_096/ov_SC03_096_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_097/ov_SC03_097_after.c b/src/ov_SC03_097/ov_SC03_097_after.c index ae3720a9b..4004615f0 100644 --- a/src/ov_SC03_097/ov_SC03_097_after.c +++ b/src/ov_SC03_097/ov_SC03_097_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_097/nonmatchings/ov_SC03_097_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_097/nonmatchings/ov_SC03_097_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_098/ov_SC03_098_after.c b/src/ov_SC03_098/ov_SC03_098_after.c index e1e1003e5..4ae646b19 100644 --- a/src/ov_SC03_098/ov_SC03_098_after.c +++ b/src/ov_SC03_098/ov_SC03_098_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_098/nonmatchings/ov_SC03_098_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_098/nonmatchings/ov_SC03_098_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_099/ov_SC03_099_after.c b/src/ov_SC03_099/ov_SC03_099_after.c index 5782060e1..0264dcf6a 100644 --- a/src/ov_SC03_099/ov_SC03_099_after.c +++ b/src/ov_SC03_099/ov_SC03_099_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_099/nonmatchings/ov_SC03_099_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_099/nonmatchings/ov_SC03_099_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_100/ov_SC03_100_after.c b/src/ov_SC03_100/ov_SC03_100_after.c index 1b967d514..d5f82c7da 100644 --- a/src/ov_SC03_100/ov_SC03_100_after.c +++ b/src/ov_SC03_100/ov_SC03_100_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_100/nonmatchings/ov_SC03_100_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_100/nonmatchings/ov_SC03_100_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_101/ov_SC03_101_after.c b/src/ov_SC03_101/ov_SC03_101_after.c index d2a586a51..914dc4ad8 100644 --- a/src/ov_SC03_101/ov_SC03_101_after.c +++ b/src/ov_SC03_101/ov_SC03_101_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_102/ov_SC03_102_after.c b/src/ov_SC03_102/ov_SC03_102_after.c index d6dfffbb7..ec34eb337 100644 --- a/src/ov_SC03_102/ov_SC03_102_after.c +++ b/src/ov_SC03_102/ov_SC03_102_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_102/nonmatchings/ov_SC03_102_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_102/nonmatchings/ov_SC03_102_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_103/ov_SC03_103_after.c b/src/ov_SC03_103/ov_SC03_103_after.c index f6e2ac432..62a139ec0 100644 --- a/src/ov_SC03_103/ov_SC03_103_after.c +++ b/src/ov_SC03_103/ov_SC03_103_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_103/nonmatchings/ov_SC03_103_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_103/nonmatchings/ov_SC03_103_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_104/ov_SC03_104_after.c b/src/ov_SC03_104/ov_SC03_104_after.c index c1d5efa21..05449194d 100644 --- a/src/ov_SC03_104/ov_SC03_104_after.c +++ b/src/ov_SC03_104/ov_SC03_104_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_104/nonmatchings/ov_SC03_104_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_104/nonmatchings/ov_SC03_104_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_105/ov_SC03_105_after.c b/src/ov_SC03_105/ov_SC03_105_after.c index ba0611c8b..53a3aba75 100644 --- a/src/ov_SC03_105/ov_SC03_105_after.c +++ b/src/ov_SC03_105/ov_SC03_105_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_108/ov_SC03_108_after.c b/src/ov_SC03_108/ov_SC03_108_after.c index ace50f930..52b565dc1 100644 --- a/src/ov_SC03_108/ov_SC03_108_after.c +++ b/src/ov_SC03_108/ov_SC03_108_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_109/ov_SC03_109_after.c b/src/ov_SC03_109/ov_SC03_109_after.c index c1239cc2a..292feb7a4 100644 --- a/src/ov_SC03_109/ov_SC03_109_after.c +++ b/src/ov_SC03_109/ov_SC03_109_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_109/nonmatchings/ov_SC03_109_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_109/nonmatchings/ov_SC03_109_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_110/ov_SC03_110_after.c b/src/ov_SC03_110/ov_SC03_110_after.c index 592bdc1ef..e422e3ebc 100644 --- a/src/ov_SC03_110/ov_SC03_110_after.c +++ b/src/ov_SC03_110/ov_SC03_110_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_110/nonmatchings/ov_SC03_110_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_110/nonmatchings/ov_SC03_110_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_111/ov_SC03_111_after.c b/src/ov_SC03_111/ov_SC03_111_after.c index bc1d2f858..54e6853fe 100644 --- a/src/ov_SC03_111/ov_SC03_111_after.c +++ b/src/ov_SC03_111/ov_SC03_111_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_111/nonmatchings/ov_SC03_111_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_111/nonmatchings/ov_SC03_111_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_112/ov_SC03_112_after.c b/src/ov_SC03_112/ov_SC03_112_after.c index 12c1cb39c..a4b08e657 100644 --- a/src/ov_SC03_112/ov_SC03_112_after.c +++ b/src/ov_SC03_112/ov_SC03_112_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_112/nonmatchings/ov_SC03_112_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_112/nonmatchings/ov_SC03_112_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_113/ov_SC03_113_after.c b/src/ov_SC03_113/ov_SC03_113_after.c index c32f43014..9d7a6dc1a 100644 --- a/src/ov_SC03_113/ov_SC03_113_after.c +++ b/src/ov_SC03_113/ov_SC03_113_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_113/nonmatchings/ov_SC03_113_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_113/nonmatchings/ov_SC03_113_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_114/ov_SC03_114_after.c b/src/ov_SC03_114/ov_SC03_114_after.c index fb775c1bc..d0cd7a84f 100644 --- a/src/ov_SC03_114/ov_SC03_114_after.c +++ b/src/ov_SC03_114/ov_SC03_114_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_114/nonmatchings/ov_SC03_114_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_114/nonmatchings/ov_SC03_114_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_115/ov_SC03_115_after.c b/src/ov_SC03_115/ov_SC03_115_after.c index f21554ff0..393956264 100644 --- a/src/ov_SC03_115/ov_SC03_115_after.c +++ b/src/ov_SC03_115/ov_SC03_115_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_116/ov_SC03_116_after.c b/src/ov_SC03_116/ov_SC03_116_after.c index 4be6a14d5..ab5480081 100644 --- a/src/ov_SC03_116/ov_SC03_116_after.c +++ b/src/ov_SC03_116/ov_SC03_116_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_117/ov_SC03_117_after.c b/src/ov_SC03_117/ov_SC03_117_after.c index a8af1db14..1cd045b0e 100644 --- a/src/ov_SC03_117/ov_SC03_117_after.c +++ b/src/ov_SC03_117/ov_SC03_117_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_117/nonmatchings/ov_SC03_117_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_117/nonmatchings/ov_SC03_117_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_118/ov_SC03_118_after.c b/src/ov_SC03_118/ov_SC03_118_after.c index 4395a48f4..787848293 100644 --- a/src/ov_SC03_118/ov_SC03_118_after.c +++ b/src/ov_SC03_118/ov_SC03_118_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_118/nonmatchings/ov_SC03_118_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_118/nonmatchings/ov_SC03_118_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_119/ov_SC03_119_after.c b/src/ov_SC03_119/ov_SC03_119_after.c index 3d693036c..b1438f4b4 100644 --- a/src/ov_SC03_119/ov_SC03_119_after.c +++ b/src/ov_SC03_119/ov_SC03_119_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_121/ov_SC03_121_after.c b/src/ov_SC03_121/ov_SC03_121_after.c index 986189624..2cfcc4742 100644 --- a/src/ov_SC03_121/ov_SC03_121_after.c +++ b/src/ov_SC03_121/ov_SC03_121_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_121/nonmatchings/ov_SC03_121_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_121/nonmatchings/ov_SC03_121_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_124/ov_SC03_124_after.c b/src/ov_SC03_124/ov_SC03_124_after.c index dcb8d73a7..9a3cd5db6 100644 --- a/src/ov_SC03_124/ov_SC03_124_after.c +++ b/src/ov_SC03_124/ov_SC03_124_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_125/ov_SC03_125_after.c b/src/ov_SC03_125/ov_SC03_125_after.c index d7b3f34cb..6b91ea743 100644 --- a/src/ov_SC03_125/ov_SC03_125_after.c +++ b/src/ov_SC03_125/ov_SC03_125_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC03_126/ov_SC03_126_after.c b/src/ov_SC03_126/ov_SC03_126_after.c index 3f1ddb0ba..d56ce78d7 100644 --- a/src/ov_SC03_126/ov_SC03_126_after.c +++ b/src/ov_SC03_126/ov_SC03_126_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC03_126/nonmatchings/ov_SC03_126_after", func_80150170); -INCLUDE_ASM("asm/ov_SC03_126/nonmatchings/ov_SC03_126_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_000/ov_SC04_000_after.c b/src/ov_SC04_000/ov_SC04_000_after.c index 4bf664791..f7aa43aaf 100644 --- a/src/ov_SC04_000/ov_SC04_000_after.c +++ b/src/ov_SC04_000/ov_SC04_000_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_000/nonmatchings/ov_SC04_000_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_000/nonmatchings/ov_SC04_000_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_002/ov_SC04_002_after.c b/src/ov_SC04_002/ov_SC04_002_after.c index 49858e7de..90becee60 100644 --- a/src/ov_SC04_002/ov_SC04_002_after.c +++ b/src/ov_SC04_002/ov_SC04_002_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_003/ov_SC04_003_after.c b/src/ov_SC04_003/ov_SC04_003_after.c index e3ecafcec..4a46f908e 100644 --- a/src/ov_SC04_003/ov_SC04_003_after.c +++ b/src/ov_SC04_003/ov_SC04_003_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_003/nonmatchings/ov_SC04_003_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_003/nonmatchings/ov_SC04_003_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_004/ov_SC04_004_after.c b/src/ov_SC04_004/ov_SC04_004_after.c index e0e7b11d6..a26320cf3 100644 --- a/src/ov_SC04_004/ov_SC04_004_after.c +++ b/src/ov_SC04_004/ov_SC04_004_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_005/ov_SC04_005_after.c b/src/ov_SC04_005/ov_SC04_005_after.c index 56130aa86..093ad9f06 100644 --- a/src/ov_SC04_005/ov_SC04_005_after.c +++ b/src/ov_SC04_005/ov_SC04_005_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_006/ov_SC04_006_after.c b/src/ov_SC04_006/ov_SC04_006_after.c index ea90b274f..cff2d41fe 100644 --- a/src/ov_SC04_006/ov_SC04_006_after.c +++ b/src/ov_SC04_006/ov_SC04_006_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_006/nonmatchings/ov_SC04_006_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_006/nonmatchings/ov_SC04_006_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_007/ov_SC04_007_after.c b/src/ov_SC04_007/ov_SC04_007_after.c index b2375c20d..634baaac6 100644 --- a/src/ov_SC04_007/ov_SC04_007_after.c +++ b/src/ov_SC04_007/ov_SC04_007_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_008/ov_SC04_008_after.c b/src/ov_SC04_008/ov_SC04_008_after.c index fee74483f..4ccf66de8 100644 --- a/src/ov_SC04_008/ov_SC04_008_after.c +++ b/src/ov_SC04_008/ov_SC04_008_after.c @@ -1920,7 +1920,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_008/nonmatchings/ov_SC04_008_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_008/nonmatchings/ov_SC04_008_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_009/ov_SC04_009_after.c b/src/ov_SC04_009/ov_SC04_009_after.c index 6d0408acd..2cc9a947e 100644 --- a/src/ov_SC04_009/ov_SC04_009_after.c +++ b/src/ov_SC04_009/ov_SC04_009_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_009/nonmatchings/ov_SC04_009_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_009/nonmatchings/ov_SC04_009_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_010/ov_SC04_010_after.c b/src/ov_SC04_010/ov_SC04_010_after.c index da690618b..f06c57705 100644 --- a/src/ov_SC04_010/ov_SC04_010_after.c +++ b/src/ov_SC04_010/ov_SC04_010_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_010/nonmatchings/ov_SC04_010_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_010/nonmatchings/ov_SC04_010_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_011/ov_SC04_011_after.c b/src/ov_SC04_011/ov_SC04_011_after.c index 2bee1cb4a..592eee7e6 100644 --- a/src/ov_SC04_011/ov_SC04_011_after.c +++ b/src/ov_SC04_011/ov_SC04_011_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_012/ov_SC04_012_after.c b/src/ov_SC04_012/ov_SC04_012_after.c index 9b60c1706..fca0bacb4 100644 --- a/src/ov_SC04_012/ov_SC04_012_after.c +++ b/src/ov_SC04_012/ov_SC04_012_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_012/nonmatchings/ov_SC04_012_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_012/nonmatchings/ov_SC04_012_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_015/ov_SC04_015_after.c b/src/ov_SC04_015/ov_SC04_015_after.c index c96048246..485885b1c 100644 --- a/src/ov_SC04_015/ov_SC04_015_after.c +++ b/src/ov_SC04_015/ov_SC04_015_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_015/nonmatchings/ov_SC04_015_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_015/nonmatchings/ov_SC04_015_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_016/ov_SC04_016_after.c b/src/ov_SC04_016/ov_SC04_016_after.c index 880766327..af801af02 100644 --- a/src/ov_SC04_016/ov_SC04_016_after.c +++ b/src/ov_SC04_016/ov_SC04_016_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_016/nonmatchings/ov_SC04_016_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_016/nonmatchings/ov_SC04_016_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_018/ov_SC04_018_after.c b/src/ov_SC04_018/ov_SC04_018_after.c index 352fa5032..d3c9afa2b 100644 --- a/src/ov_SC04_018/ov_SC04_018_after.c +++ b/src/ov_SC04_018/ov_SC04_018_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_019/ov_SC04_019_after.c b/src/ov_SC04_019/ov_SC04_019_after.c index adeabddbd..4bf5634ea 100644 --- a/src/ov_SC04_019/ov_SC04_019_after.c +++ b/src/ov_SC04_019/ov_SC04_019_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_020/ov_SC04_020_after.c b/src/ov_SC04_020/ov_SC04_020_after.c index 9dbe2dcb5..a9c74b921 100644 --- a/src/ov_SC04_020/ov_SC04_020_after.c +++ b/src/ov_SC04_020/ov_SC04_020_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_020/nonmatchings/ov_SC04_020_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_020/nonmatchings/ov_SC04_020_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC04_021/ov_SC04_021_after.c b/src/ov_SC04_021/ov_SC04_021_after.c index 49c96e387..03b8d9d76 100644 --- a/src/ov_SC04_021/ov_SC04_021_after.c +++ b/src/ov_SC04_021/ov_SC04_021_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC04_021/nonmatchings/ov_SC04_021_after", func_80150170); -INCLUDE_ASM("asm/ov_SC04_021/nonmatchings/ov_SC04_021_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_000/ov_SC05_000_after.c b/src/ov_SC05_000/ov_SC05_000_after.c index e2d1aa82b..ce403f1ee 100644 --- a/src/ov_SC05_000/ov_SC05_000_after.c +++ b/src/ov_SC05_000/ov_SC05_000_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_000/nonmatchings/ov_SC05_000_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_000/nonmatchings/ov_SC05_000_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_001/ov_SC05_001_after.c b/src/ov_SC05_001/ov_SC05_001_after.c index 31b42e4d1..3fd4f92d2 100644 --- a/src/ov_SC05_001/ov_SC05_001_after.c +++ b/src/ov_SC05_001/ov_SC05_001_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_001/nonmatchings/ov_SC05_001_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_001/nonmatchings/ov_SC05_001_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_002/ov_SC05_002_after.c b/src/ov_SC05_002/ov_SC05_002_after.c index fdb69697d..a9786ebae 100644 --- a/src/ov_SC05_002/ov_SC05_002_after.c +++ b/src/ov_SC05_002/ov_SC05_002_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_003/ov_SC05_003_after.c b/src/ov_SC05_003/ov_SC05_003_after.c index 48fe23f74..29327914e 100644 --- a/src/ov_SC05_003/ov_SC05_003_after.c +++ b/src/ov_SC05_003/ov_SC05_003_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_004/ov_SC05_004_after.c b/src/ov_SC05_004/ov_SC05_004_after.c index 90ce44066..c869f3972 100644 --- a/src/ov_SC05_004/ov_SC05_004_after.c +++ b/src/ov_SC05_004/ov_SC05_004_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_004/nonmatchings/ov_SC05_004_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_004/nonmatchings/ov_SC05_004_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_005/ov_SC05_005_after.c b/src/ov_SC05_005/ov_SC05_005_after.c index 0c7035903..72cdcb0b6 100644 --- a/src/ov_SC05_005/ov_SC05_005_after.c +++ b/src/ov_SC05_005/ov_SC05_005_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_005/nonmatchings/ov_SC05_005_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_005/nonmatchings/ov_SC05_005_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_006/ov_SC05_006_after.c b/src/ov_SC05_006/ov_SC05_006_after.c index e338e50c6..f30a0ba88 100644 --- a/src/ov_SC05_006/ov_SC05_006_after.c +++ b/src/ov_SC05_006/ov_SC05_006_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_006/nonmatchings/ov_SC05_006_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_006/nonmatchings/ov_SC05_006_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_007/ov_SC05_007_after.c b/src/ov_SC05_007/ov_SC05_007_after.c index 9765b1522..eaa768c5c 100644 --- a/src/ov_SC05_007/ov_SC05_007_after.c +++ b/src/ov_SC05_007/ov_SC05_007_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_008/ov_SC05_008_after.c b/src/ov_SC05_008/ov_SC05_008_after.c index 0aa2c9467..434c91295 100644 --- a/src/ov_SC05_008/ov_SC05_008_after.c +++ b/src/ov_SC05_008/ov_SC05_008_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_008_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_009/ov_SC05_009_after.c b/src/ov_SC05_009/ov_SC05_009_after.c index 1acbe910a..49cf24275 100644 --- a/src/ov_SC05_009/ov_SC05_009_after.c +++ b/src/ov_SC05_009/ov_SC05_009_after.c @@ -1920,7 +1920,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_009/nonmatchings/ov_SC05_009_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_009/nonmatchings/ov_SC05_009_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_010/ov_SC05_010_after.c b/src/ov_SC05_010/ov_SC05_010_after.c index 1a5b120a4..3c01e532d 100644 --- a/src/ov_SC05_010/ov_SC05_010_after.c +++ b/src/ov_SC05_010/ov_SC05_010_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_011/ov_SC05_011_after.c b/src/ov_SC05_011/ov_SC05_011_after.c index c5c084dd3..930170eba 100644 --- a/src/ov_SC05_011/ov_SC05_011_after.c +++ b/src/ov_SC05_011/ov_SC05_011_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_011/nonmatchings/ov_SC05_011_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_011/nonmatchings/ov_SC05_011_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_017/ov_SC05_017_after.c b/src/ov_SC05_017/ov_SC05_017_after.c index a52b982b9..17b5cc592 100644 --- a/src/ov_SC05_017/ov_SC05_017_after.c +++ b/src/ov_SC05_017/ov_SC05_017_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_017/nonmatchings/ov_SC05_017_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_017/nonmatchings/ov_SC05_017_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_018/ov_SC05_018_after.c b/src/ov_SC05_018/ov_SC05_018_after.c index d21c5beeb..0153690d2 100644 --- a/src/ov_SC05_018/ov_SC05_018_after.c +++ b/src/ov_SC05_018/ov_SC05_018_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_018_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC05_019/ov_SC05_019_after.c b/src/ov_SC05_019/ov_SC05_019_after.c index 70a53a367..7af03b893 100644 --- a/src/ov_SC05_019/ov_SC05_019_after.c +++ b/src/ov_SC05_019/ov_SC05_019_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC05_019/nonmatchings/ov_SC05_019_after", func_80150170); -INCLUDE_ASM("asm/ov_SC05_019/nonmatchings/ov_SC05_019_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_000/ov_SC06_000_after.c b/src/ov_SC06_000/ov_SC06_000_after.c index 5bfe49c6d..b956e8e6f 100644 --- a/src/ov_SC06_000/ov_SC06_000_after.c +++ b/src/ov_SC06_000/ov_SC06_000_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_000_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_006/ov_SC06_006_after.c b/src/ov_SC06_006/ov_SC06_006_after.c index 33659bbd3..32f420f4b 100644 --- a/src/ov_SC06_006/ov_SC06_006_after.c +++ b/src/ov_SC06_006/ov_SC06_006_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_006_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_008/ov_SC06_008_after.c b/src/ov_SC06_008/ov_SC06_008_after.c index 0b775322d..bf8103cbf 100644 --- a/src/ov_SC06_008/ov_SC06_008_after.c +++ b/src/ov_SC06_008/ov_SC06_008_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_008/nonmatchings/ov_SC06_008_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_008/nonmatchings/ov_SC06_008_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_010/ov_SC06_010_after.c b/src/ov_SC06_010/ov_SC06_010_after.c index 7578744e5..0a6fe18b4 100644 --- a/src/ov_SC06_010/ov_SC06_010_after.c +++ b/src/ov_SC06_010/ov_SC06_010_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_010/nonmatchings/ov_SC06_010_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_010/nonmatchings/ov_SC06_010_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_011/ov_SC06_011_after.c b/src/ov_SC06_011/ov_SC06_011_after.c index 66d089703..b23da283a 100644 --- a/src/ov_SC06_011/ov_SC06_011_after.c +++ b/src/ov_SC06_011/ov_SC06_011_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_011/nonmatchings/ov_SC06_011_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_011/nonmatchings/ov_SC06_011_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_013/ov_SC06_013_after.c b/src/ov_SC06_013/ov_SC06_013_after.c index 044f5e63b..0840c707d 100644 --- a/src/ov_SC06_013/ov_SC06_013_after.c +++ b/src/ov_SC06_013/ov_SC06_013_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_013/nonmatchings/ov_SC06_013_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_013/nonmatchings/ov_SC06_013_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_014/ov_SC06_014_after.c b/src/ov_SC06_014/ov_SC06_014_after.c index c9869f162..f6af3356a 100644 --- a/src/ov_SC06_014/ov_SC06_014_after.c +++ b/src/ov_SC06_014/ov_SC06_014_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_014/nonmatchings/ov_SC06_014_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_014/nonmatchings/ov_SC06_014_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_015/ov_SC06_015_after.c b/src/ov_SC06_015/ov_SC06_015_after.c index 39a4b0563..384d1e2b6 100644 --- a/src/ov_SC06_015/ov_SC06_015_after.c +++ b/src/ov_SC06_015/ov_SC06_015_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_015/nonmatchings/ov_SC06_015_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_015/nonmatchings/ov_SC06_015_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_016/ov_SC06_016_after.c b/src/ov_SC06_016/ov_SC06_016_after.c index b2948e262..9914467ea 100644 --- a/src/ov_SC06_016/ov_SC06_016_after.c +++ b/src/ov_SC06_016/ov_SC06_016_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_018/ov_SC06_018_after.c b/src/ov_SC06_018/ov_SC06_018_after.c index ab739686a..1ed7a543b 100644 --- a/src/ov_SC06_018/ov_SC06_018_after.c +++ b/src/ov_SC06_018/ov_SC06_018_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_018/nonmatchings/ov_SC06_018_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_018/nonmatchings/ov_SC06_018_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_020/ov_SC06_020_after.c b/src/ov_SC06_020/ov_SC06_020_after.c index 39bdd8aa2..d2701eb5d 100644 --- a/src/ov_SC06_020/ov_SC06_020_after.c +++ b/src/ov_SC06_020/ov_SC06_020_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_020/nonmatchings/ov_SC06_020_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_020/nonmatchings/ov_SC06_020_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_022/ov_SC06_022_after.c b/src/ov_SC06_022/ov_SC06_022_after.c index fb0422c05..412b1dc92 100644 --- a/src/ov_SC06_022/ov_SC06_022_after.c +++ b/src/ov_SC06_022/ov_SC06_022_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_024/ov_SC06_024_after.c b/src/ov_SC06_024/ov_SC06_024_after.c index 0966fdb0e..8bb77a6f4 100644 --- a/src/ov_SC06_024/ov_SC06_024_after.c +++ b/src/ov_SC06_024/ov_SC06_024_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_025/ov_SC06_025_after.c b/src/ov_SC06_025/ov_SC06_025_after.c index a7744276d..0d04b7381 100644 --- a/src/ov_SC06_025/ov_SC06_025_after.c +++ b/src/ov_SC06_025/ov_SC06_025_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_027/ov_SC06_027_after.c b/src/ov_SC06_027/ov_SC06_027_after.c index 0e335d2a9..973b52d2c 100644 --- a/src/ov_SC06_027/ov_SC06_027_after.c +++ b/src/ov_SC06_027/ov_SC06_027_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_027/nonmatchings/ov_SC06_027_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_027/nonmatchings/ov_SC06_027_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_029/ov_SC06_029_after.c b/src/ov_SC06_029/ov_SC06_029_after.c index 245f64181..73b2f2abe 100644 --- a/src/ov_SC06_029/ov_SC06_029_after.c +++ b/src/ov_SC06_029/ov_SC06_029_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_029_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_030/ov_SC06_030_after.c b/src/ov_SC06_030/ov_SC06_030_after.c index 81a3bbcf9..7ca0d02d2 100644 --- a/src/ov_SC06_030/ov_SC06_030_after.c +++ b/src/ov_SC06_030/ov_SC06_030_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_030/nonmatchings/ov_SC06_030_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_030/nonmatchings/ov_SC06_030_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_032/ov_SC06_032_after.c b/src/ov_SC06_032/ov_SC06_032_after.c index 39ae8cf98..ad4588590 100644 --- a/src/ov_SC06_032/ov_SC06_032_after.c +++ b/src/ov_SC06_032/ov_SC06_032_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC06_033/ov_SC06_033_after.c b/src/ov_SC06_033/ov_SC06_033_after.c index d6a490f5e..afb95d195 100644 --- a/src/ov_SC06_033/ov_SC06_033_after.c +++ b/src/ov_SC06_033/ov_SC06_033_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_after", func_80150170); -INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC07_000/ov_SC07_000_after.c b/src/ov_SC07_000/ov_SC07_000_after.c index ee6da1c78..38bce8152 100644 --- a/src/ov_SC07_000/ov_SC07_000_after.c +++ b/src/ov_SC07_000/ov_SC07_000_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_after", func_80150170); -INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC07_001/ov_SC07_001_after.c b/src/ov_SC07_001/ov_SC07_001_after.c index ab87cb9f3..e920861b1 100644 --- a/src/ov_SC07_001/ov_SC07_001_after.c +++ b/src/ov_SC07_001/ov_SC07_001_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC07_001/nonmatchings/ov_SC07_001_after", func_80150170); -INCLUDE_ASM("asm/ov_SC07_001/nonmatchings/ov_SC07_001_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC07_002/ov_SC07_002_after.c b/src/ov_SC07_002/ov_SC07_002_after.c index 0265e6a63..7f1811107 100644 --- a/src/ov_SC07_002/ov_SC07_002_after.c +++ b/src/ov_SC07_002/ov_SC07_002_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_after", func_80150170); -INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_002_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC07_006/ov_SC07_006_jr_80131340.c b/src/ov_SC07_006/ov_SC07_006_jr_80131340.c index fb1cbbc8e..a89914f65 100644 --- a/src/ov_SC07_006/ov_SC07_006_jr_80131340.c +++ b/src/ov_SC07_006/ov_SC07_006_jr_80131340.c @@ -815,7 +815,78 @@ INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_80131340", func_80131A3 DEFINE_func_80131AC8() /* dedup: shared engine-core @0x80131ac8 (src/shared) */ -INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_80131340", func_80131B14); +extern void func_80019064(void *a0); +extern void func_8012B23C(s32 a0); +extern void func_8012B2CC(s32 a0); +extern void func_8016AA50(int, int); +extern void func_8016B428(int); + +// @class: regalloc-order +// @stuck: none — MATCH (89 ins). Reconcile: TU canonical decl is `void func_80131B14(void)` +// (ov_SC01_077_a.c L1676/L1756; callers cast to (void(*)(int)) when passing p), so the def MUST be +// (void) or cc1 hard-errors `conflicting types` (exit 33). §42c lever #6: capture incoming $a0 into a +// NORMAL pseudo (`register u8 *a0v __asm__("$4"); u8 *p = a0v;`) so p gets a callee-saved home ($s0). +// func_8012B2CC/func_8012B23C are file-scope DEFINE'd here (split L740/L744) as void(s32) — do NOT redeclare; +// the (void(*)(void*)) cast on the bare name is byte-neutral. Body keys: e(0x5E) as s32 not u8 (kills the +// compare-time andi 0xff); f76 dual-width via per-access casts (lhu in the decrement, lh in the <=0 compare); +// the p->f20 reload split into TWO separate temps so the 2nd load takes $v0 not $v1. + +void func_80131B14() { + register u8 *a0v __asm__("$4"); + u8 *p = a0v; + + extern void func_8002A520(void *); + extern void func_8002A790(void *); + extern u8 D_8018A8CC; + + s32 e = *(u8 *)(p + 0x5E); + + if (*(s16 *)(p + 0x60) != 0) { + if (e == 0x1D) { + *(s16 *)(p + 0x82) = 0; + *(s16 *)(p + 0x7C) = *(u16 *)(p + 0x06); + *(s16 *)(p + 0x7E) = *(u16 *)(p + 0x0A); + *(s16 *)(p + 0x80) = *(u16 *)(p + 0x0E); + } + { + s32 dec; + s32 q = *(s32 *)(p + 0x78); + if (q != 0) { + dec = ((s32)*(s16 *)(p + 0x60) * (s32)*(s16 *)(q + 0x30)) >> 12; + if (dec <= 0) dec = 1; + } + *(u16 *)(p + 0x76) = *(u16 *)(p + 0x76) - dec; + } + ((void (*)(void *))func_8016AA50)(p); + if (*(u16 *)(p + 0x82) & 1) { + ((void (*)(void *))func_8016B428)(p); + ((void(*)(void *))func_80019064)(&D_8018A8CC); + } + } + + *(u16 *)(p + 0x5C) = *(u16 *)(p + 0x5C) & 0xFFFE; + + if (e != 0x1D) { + if (*(u8 *)(p + 0xC8)) func_8002A520(p); + if (*(u8 *)(p + 0xC9)) func_8002A790(p); + } + + if (*(s16 *)(p + 0x76) <= 0) *(s16 *)(p + 0x5C) = 0; + + { + s32 r = *(s32 *)(p + 0x20); + *(s16 *)(r + 0x12) = (*(u16 *)(p + 0x62) + 0x800) & 0xFFF; + { + s32 r2 = *(s32 *)(p + 0x20); + *(s16 *)(r2 + 0x14) = 0; + *(s16 *)(r2 + 0x10) = 0; + } + } + + ((void (*)(void *))func_8012B2CC)(p); + ((void (*)(void *))func_8012B23C)(p); +} + DEFINE_func_80131C78() /* dedup: shared engine-core @0x80131c78 (src/shared) */ diff --git a/src/ov_SC07_007/ov_SC07_007_jr_80131340.c b/src/ov_SC07_007/ov_SC07_007_jr_80131340.c index 805eb1247..99462790d 100644 --- a/src/ov_SC07_007/ov_SC07_007_jr_80131340.c +++ b/src/ov_SC07_007/ov_SC07_007_jr_80131340.c @@ -815,7 +815,78 @@ INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_80131340", func_80131A3 DEFINE_func_80131AC8() /* dedup: shared engine-core @0x80131ac8 (src/shared) */ -INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_80131340", func_80131B14); +extern void func_80019064(void *a0); +extern void func_8012B23C(s32 a0); +extern void func_8012B2CC(s32 a0); +extern void func_8016AA50(int, int); +extern void func_8016B428(int); + +// @class: regalloc-order +// @stuck: none — MATCH (89 ins). Reconcile: TU canonical decl is `void func_80131B14(void)` +// (ov_SC01_077_a.c L1676/L1756; callers cast to (void(*)(int)) when passing p), so the def MUST be +// (void) or cc1 hard-errors `conflicting types` (exit 33). §42c lever #6: capture incoming $a0 into a +// NORMAL pseudo (`register u8 *a0v __asm__("$4"); u8 *p = a0v;`) so p gets a callee-saved home ($s0). +// func_8012B2CC/func_8012B23C are file-scope DEFINE'd here (split L740/L744) as void(s32) — do NOT redeclare; +// the (void(*)(void*)) cast on the bare name is byte-neutral. Body keys: e(0x5E) as s32 not u8 (kills the +// compare-time andi 0xff); f76 dual-width via per-access casts (lhu in the decrement, lh in the <=0 compare); +// the p->f20 reload split into TWO separate temps so the 2nd load takes $v0 not $v1. + +void func_80131B14() { + register u8 *a0v __asm__("$4"); + u8 *p = a0v; + + extern void func_8002A520(void *); + extern void func_8002A790(void *); + extern u8 D_801833F0; + + s32 e = *(u8 *)(p + 0x5E); + + if (*(s16 *)(p + 0x60) != 0) { + if (e == 0x1D) { + *(s16 *)(p + 0x82) = 0; + *(s16 *)(p + 0x7C) = *(u16 *)(p + 0x06); + *(s16 *)(p + 0x7E) = *(u16 *)(p + 0x0A); + *(s16 *)(p + 0x80) = *(u16 *)(p + 0x0E); + } + { + s32 dec; + s32 q = *(s32 *)(p + 0x78); + if (q != 0) { + dec = ((s32)*(s16 *)(p + 0x60) * (s32)*(s16 *)(q + 0x30)) >> 12; + if (dec <= 0) dec = 1; + } + *(u16 *)(p + 0x76) = *(u16 *)(p + 0x76) - dec; + } + ((void (*)(void *))func_8016AA50)(p); + if (*(u16 *)(p + 0x82) & 1) { + ((void (*)(void *))func_8016B428)(p); + ((void(*)(void *))func_80019064)(&D_801833F0); + } + } + + *(u16 *)(p + 0x5C) = *(u16 *)(p + 0x5C) & 0xFFFE; + + if (e != 0x1D) { + if (*(u8 *)(p + 0xC8)) func_8002A520(p); + if (*(u8 *)(p + 0xC9)) func_8002A790(p); + } + + if (*(s16 *)(p + 0x76) <= 0) *(s16 *)(p + 0x5C) = 0; + + { + s32 r = *(s32 *)(p + 0x20); + *(s16 *)(r + 0x12) = (*(u16 *)(p + 0x62) + 0x800) & 0xFFF; + { + s32 r2 = *(s32 *)(p + 0x20); + *(s16 *)(r2 + 0x14) = 0; + *(s16 *)(r2 + 0x10) = 0; + } + } + + ((void (*)(void *))func_8012B2CC)(p); + ((void (*)(void *))func_8012B23C)(p); +} + DEFINE_func_80131C78() /* dedup: shared engine-core @0x80131c78 (src/shared) */ diff --git a/src/ov_SC07_008/ov_SC07_008_after.c b/src/ov_SC07_008/ov_SC07_008_after.c index 9a576d263..20348eaf0 100644 --- a/src/ov_SC07_008/ov_SC07_008_after.c +++ b/src/ov_SC07_008/ov_SC07_008_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC07_008/nonmatchings/ov_SC07_008_after", func_80150170); -INCLUDE_ASM("asm/ov_SC07_008/nonmatchings/ov_SC07_008_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC07_009/ov_SC07_009_after.c b/src/ov_SC07_009/ov_SC07_009_after.c index 502e07ae5..ffd78c5f3 100644 --- a/src/ov_SC07_009/ov_SC07_009_after.c +++ b/src/ov_SC07_009/ov_SC07_009_after.c @@ -1926,7 +1926,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC07_009/nonmatchings/ov_SC07_009_after", func_80150170); -INCLUDE_ASM("asm/ov_SC07_009/nonmatchings/ov_SC07_009_after", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (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 c2c01292f..874f8d502 100644 --- a/src/ov_SC07_010/ov_SC07_010_o2b.c +++ b/src/ov_SC07_010/ov_SC07_010_o2b.c @@ -4538,7 +4538,47 @@ DEFINE_func_80150150() /* dedup: shared engine-core @0x80150150 (src/shared) */ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_o2b", func_80150170); -INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_o2b", func_801502EC); + +extern s32 func_80135D20(s32 a0, s32 a1, void *a2); + + + +s32 func_801502EC(s32 e, void *a1, void *a2) { + + extern u8 D_801202A0[]; + extern u8 D_80126720[]; + extern u8 D_801152A8[]; + Vec8 save; + Vec8 test; + s32 found; + u8 *p; + + found = 0; + __builtin_memcpy(&save, a1, 8); + *(s16 *)((s32)a1 + 2) = 0x7fff; + p = D_801202A0; + if (p < p + 0x6480) { + do { + if (*(u16 *)p != 0) { + if ((*(u16 *)(p + 0x5C) & 0x400) != 0) { + if (*(s32 *)(p + 0x58) != 0) { + test = save; + if (func_80135D20(*(s32 *)(p + 0x20), *(s32 *)(p + 0x58), &test) != 0) { + found = 1; + if (test.unk2 < *(s16 *)((s32)a1 + 2)) { + __builtin_memcpy(a1, &test, 8); + __builtin_memcpy(a2, D_801152A8, 8); + } + } + } + } + } + p += 0x10C; + } while (p < D_80126720); + } + return found; +} + DEFINE_func_80150460() /* dedup: shared engine-core @0x80150460 (src/shared) */ diff --git a/src/ov_SC07_011/ov_SC07_011_jr_80131340.c b/src/ov_SC07_011/ov_SC07_011_jr_80131340.c index ccf29bbe6..4a8c79b96 100644 --- a/src/ov_SC07_011/ov_SC07_011_jr_80131340.c +++ b/src/ov_SC07_011/ov_SC07_011_jr_80131340.c @@ -815,7 +815,78 @@ INCLUDE_ASM("asm/ov_SC07_011/nonmatchings/ov_SC07_011_jr_80131340", func_80131A3 DEFINE_func_80131AC8() /* dedup: shared engine-core @0x80131ac8 (src/shared) */ -INCLUDE_ASM("asm/ov_SC07_011/nonmatchings/ov_SC07_011_jr_80131340", func_80131B14); +extern void func_80019064(void *a0); +extern void func_8012B23C(s32 a0); +extern void func_8012B2CC(s32 a0); +extern void func_8016AA50(int, int); +extern void func_8016B428(int); + +// @class: regalloc-order +// @stuck: none — MATCH (89 ins). Reconcile: TU canonical decl is `void func_80131B14(void)` +// (ov_SC01_077_a.c L1676/L1756; callers cast to (void(*)(int)) when passing p), so the def MUST be +// (void) or cc1 hard-errors `conflicting types` (exit 33). §42c lever #6: capture incoming $a0 into a +// NORMAL pseudo (`register u8 *a0v __asm__("$4"); u8 *p = a0v;`) so p gets a callee-saved home ($s0). +// func_8012B2CC/func_8012B23C are file-scope DEFINE'd here (split L740/L744) as void(s32) — do NOT redeclare; +// the (void(*)(void*)) cast on the bare name is byte-neutral. Body keys: e(0x5E) as s32 not u8 (kills the +// compare-time andi 0xff); f76 dual-width via per-access casts (lhu in the decrement, lh in the <=0 compare); +// the p->f20 reload split into TWO separate temps so the 2nd load takes $v0 not $v1. + +void func_80131B14() { + register u8 *a0v __asm__("$4"); + u8 *p = a0v; + + extern void func_8002A520(void *); + extern void func_8002A790(void *); + extern u8 D_8017EB40; + + s32 e = *(u8 *)(p + 0x5E); + + if (*(s16 *)(p + 0x60) != 0) { + if (e == 0x1D) { + *(s16 *)(p + 0x82) = 0; + *(s16 *)(p + 0x7C) = *(u16 *)(p + 0x06); + *(s16 *)(p + 0x7E) = *(u16 *)(p + 0x0A); + *(s16 *)(p + 0x80) = *(u16 *)(p + 0x0E); + } + { + s32 dec; + s32 q = *(s32 *)(p + 0x78); + if (q != 0) { + dec = ((s32)*(s16 *)(p + 0x60) * (s32)*(s16 *)(q + 0x30)) >> 12; + if (dec <= 0) dec = 1; + } + *(u16 *)(p + 0x76) = *(u16 *)(p + 0x76) - dec; + } + ((void (*)(void *))func_8016AA50)(p); + if (*(u16 *)(p + 0x82) & 1) { + ((void (*)(void *))func_8016B428)(p); + ((void(*)(void *))func_80019064)(&D_8017EB40); + } + } + + *(u16 *)(p + 0x5C) = *(u16 *)(p + 0x5C) & 0xFFFE; + + if (e != 0x1D) { + if (*(u8 *)(p + 0xC8)) func_8002A520(p); + if (*(u8 *)(p + 0xC9)) func_8002A790(p); + } + + if (*(s16 *)(p + 0x76) <= 0) *(s16 *)(p + 0x5C) = 0; + + { + s32 r = *(s32 *)(p + 0x20); + *(s16 *)(r + 0x12) = (*(u16 *)(p + 0x62) + 0x800) & 0xFFF; + { + s32 r2 = *(s32 *)(p + 0x20); + *(s16 *)(r2 + 0x14) = 0; + *(s16 *)(r2 + 0x10) = 0; + } + } + + ((void (*)(void *))func_8012B2CC)(p); + ((void (*)(void *))func_8012B23C)(p); +} + DEFINE_func_80131C78() /* dedup: shared engine-core @0x80131c78 (src/shared) */