feat(phase-29 broad-sweep): +137 (func_801502EC x134 + func_80131B14 x3) via --fix-def-sig

- 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

@@ -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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */
 

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) */