feat(phase-30): the "137 no matched unit" family banked 137/137 (func_8016191C x137)

The skip class that the SESSION-27 checkpoint carried as "~137 members, a cheap
sweep-routing gap" is closed: ONE exemplar, ALL 137 same-address members banked,
0 failed, in a single --only sweep after the extract_unit alias fix (commit:1260).

- family_sweep --hseq --only 0x8016191C --band all -j 8, under tools/treelock.sh
  (the campaign-wide mutex, not a pgrep poll).
- BANKED 137 member-matches / 0 failed across 137 overlays; skipped {}.
- 24 ins x 137 = 3,288 instructions that were sitting behind a tool lookup miss.
- R37 probe before the sweep: rtu_match MATCH (24 ins) on 3 members in the REAL
  TU (ov_SC01_000 / _001 / _004) before spending 137 gate cycles.

R22 CLEAN-FLEET: make clean && make extract-all && make check-all ->
  extract-all: 139 extracted, 0 failed of 139 (+ main, serial)
  check-all:   140 passed,  0 failed of 140      <- BYTE-IDENTICAL
0 NON_MATCHING in any default build (G4). The whole-binary byte-gate was the sole
arbiter for every one of the 137 (G3/P9).

Note --band: the sweep defaults to band=substantial and this family is band=mid,
so the first invocation returned "0 matched-exemplar families" — a silent-looking
zero that is a FILTER, not a wall. --band all is required for mid/tiny families.

src/ov_SC01_000/ov_SC01_000_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_000/nonmatchings/ov_SC01_000_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c

@@ -3465,7 +3465,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_004/nonmatchings/ov_SC01_004_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c

@@ -3468,7 +3468,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_005/nonmatchings/ov_SC01_005_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC01_006/ov_SC01_006_jr_8015C32C.c

@@ -3468,7 +3468,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_006/nonmatchings/ov_SC01_006_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_008/nonmatchings/ov_SC01_008_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_009/nonmatchings/ov_SC01_009_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_074/nonmatchings/ov_SC01_074_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC01_084/nonmatchings/ov_SC01_084_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c

@@ -3465,7 +3465,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_000/nonmatchings/ov_SC02_000_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_003/ov_SC02_003_jr_8015C32C.c

@@ -3465,7 +3465,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_003/nonmatchings/ov_SC02_003_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_004/nonmatchings/ov_SC02_004_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c

@@ -3465,7 +3465,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_011/nonmatchings/ov_SC02_011_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c

@@ -3465,7 +3465,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_015/nonmatchings/ov_SC02_015_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_017/nonmatchings/ov_SC02_017_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_026/nonmatchings/ov_SC02_026_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_027/nonmatchings/ov_SC02_027_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_028/nonmatchings/ov_SC02_028_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_031/nonmatchings/ov_SC02_031_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_035/nonmatchings/ov_SC02_035_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_039/nonmatchings/ov_SC02_039_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC02_041/nonmatchings/ov_SC02_041_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_001/nonmatchings/ov_SC03_001_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_002/nonmatchings/ov_SC03_002_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_003/nonmatchings/ov_SC03_003_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_006/nonmatchings/ov_SC03_006_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_007/nonmatchings/ov_SC03_007_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_010/nonmatchings/ov_SC03_010_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_011/nonmatchings/ov_SC03_011_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_012/nonmatchings/ov_SC03_012_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_013/nonmatchings/ov_SC03_013_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_014/nonmatchings/ov_SC03_014_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_015/ov_SC03_015_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_015/nonmatchings/ov_SC03_015_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_024/nonmatchings/ov_SC03_024_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_028/nonmatchings/ov_SC03_028_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_029/nonmatchings/ov_SC03_029_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_030/nonmatchings/ov_SC03_030_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_031/nonmatchings/ov_SC03_031_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_089/nonmatchings/ov_SC03_089_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_091/nonmatchings/ov_SC03_091_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_092/nonmatchings/ov_SC03_092_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_093/nonmatchings/ov_SC03_093_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_094/nonmatchings/ov_SC03_094_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_095/nonmatchings/ov_SC03_095_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_097/nonmatchings/ov_SC03_097_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_098/nonmatchings/ov_SC03_098_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_099/nonmatchings/ov_SC03_099_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_100/nonmatchings/ov_SC03_100_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_101/nonmatchings/ov_SC03_101_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_102/nonmatchings/ov_SC03_102_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_103/nonmatchings/ov_SC03_103_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_104/nonmatchings/ov_SC03_104_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_105/nonmatchings/ov_SC03_105_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_108/nonmatchings/ov_SC03_108_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_109/nonmatchings/ov_SC03_109_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_110/nonmatchings/ov_SC03_110_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c

@@ -3467,7 +3467,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_111/nonmatchings/ov_SC03_111_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_112/nonmatchings/ov_SC03_112_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_113/nonmatchings/ov_SC03_113_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_114/nonmatchings/ov_SC03_114_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_115/nonmatchings/ov_SC03_115_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_117/nonmatchings/ov_SC03_117_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_118/nonmatchings/ov_SC03_118_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_119/ov_SC03_119_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_121/nonmatchings/ov_SC03_121_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_124/nonmatchings/ov_SC03_124_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_125/nonmatchings/ov_SC03_125_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC03_126/ov_SC03_126_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC03_126/nonmatchings/ov_SC03_126_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_000/nonmatchings/ov_SC04_000_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_002/nonmatchings/ov_SC04_002_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_003/nonmatchings/ov_SC04_003_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_006/nonmatchings/ov_SC04_006_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_007/nonmatchings/ov_SC04_007_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_008/ov_SC04_008_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_008/nonmatchings/ov_SC04_008_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_009/nonmatchings/ov_SC04_009_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_010/nonmatchings/ov_SC04_010_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_011/nonmatchings/ov_SC04_011_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_012/nonmatchings/ov_SC04_012_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_015/nonmatchings/ov_SC04_015_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_016/nonmatchings/ov_SC04_016_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_019/ov_SC04_019_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_019/nonmatchings/ov_SC04_019_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_020/nonmatchings/ov_SC04_020_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC04_021/ov_SC04_021_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC04_021/nonmatchings/ov_SC04_021_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c

@@ -3464,7 +3464,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_000/nonmatchings/ov_SC05_000_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_001/nonmatchings/ov_SC05_001_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_002/nonmatchings/ov_SC05_002_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_004/nonmatchings/ov_SC05_004_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */
 

src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c

@@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) {
 }
 
 
-INCLUDE_ASM("asm/ov_SC05_005/nonmatchings/ov_SC05_005_jr_8015C32C", func_8016191C);
+extern void func_8016151C(void *a0);
+
+
+// @class: sibling-copy (§71) + asm-label alias on the DEFINITION (§37 / §73 return-axis dodge)
+// @stuck: none — match_one MATCH (24 ins) AND rtu_match MATCH (24 ins), real TU, zero fleet edits.
+//
+// DERIVATION (§71 sibling-first, iteration 1):
+//   func_80161888 @ src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c:3640 is an already-MATCHED sibling
+//   with the identical flag-dispatch skeleton (1 / 0x4000 / 0x2000 -> 1 / 2 / 4, else 0); this
+//   target is that function minus the func_80161D20 consumer call.  Body copied verbatim, call
+//   dropped.  int/unsigned int spelling kept from the sibling.  MATCH first try.
+//
+// WHY THE ASM-LABEL ALIAS (this is the only non-obvious part):
+//   The fleet canon declares this function inside a shared macro —
+//     src/shared/engine_core.h:3567, DEFINE_func_8016151C():
+//       extern void func_8016191C(void *a0, s32 a1);
+//   but the byte-true body RETURNS s32 ($v0 = 1/2/4/0), so a plain `int func_8016191C(...)`
+//   definition dies with `conflicting types for 'func_8016191C'` in the real TU (rtu CC1 FAIL).
+//   That is §73's RETURN axis; a `void` def would DCE the $v0 constants outright.
+//   §73's prescribed fix is the fleet widen `extern void`->`extern s32` (T2 / R22) — exactly the
+//   edit already applied to the three banked siblings in this same macro block
+//   (engine_core.h:3546 func_8016163C -> s32, :3553 func_80161774 -> s32, :3560 func_80161888 -> int).
+//   The alias reaches the same place at T0 (draft-only, no tracked file touched): the C identifier
+//   is aF8016191C so no decl conflicts, while the emitted SYMBOL is func_8016191C.  The macro's
+//   caller func_8016151C keeps calling the `extern void` spelling and is byte-unaffected (it
+//   discards the return).  Verified by rtu_match, which extracts by symbol name.
+//
+//   IF the orchestrator prefers house style over zero-touch: widen engine_core.h:3567 to
+//     extern s32 func_8016191C(void *a0, s32 a1);
+//   (batch it with any other pending §73 widens, one R22) and then the alias line can be deleted
+//   and the definition renamed back to `int func_8016191C(int, unsigned int)`.  Byte-identical
+//   either way — confirmed: the same body under the plain name is match_one MATCH in isolation.
+
+extern void func_8014C010(int a0, int a1);
+
+int aF8016191C(int param_1, unsigned int param_2) __asm__("func_8016191C");
+
+int aF8016191C(int param_1, unsigned int param_2) {
+    if (param_2 & 1) {
+        func_8014C010(param_1, 1);
+        return 1;
+    }
+    if (param_2 & 0x4000) {
+        func_8014C010(param_1, 1);
+        return 2;
+    }
+    if (param_2 & 0x2000) {
+        func_8014C010(param_1, 1);
+        return 4;
+    }
+    return 0;
+}
+
 
 DEFINE_func_8016197C()  /* dedup: shared engine-core @0x8016197C (src/shared) */