From 9a30466de4626424a4257aa5cf45075ff010f737 Mon Sep 17 00:00:00 2001 From: Drew T <50529377+Druthulu@users.noreply.github.com> Date: Fri, 31 Jul 2026 07:52:37 -0600 Subject: [PATCH] feat(phase-30): the "137 no matched unit" family banked 137/137 (func_8016191C x137) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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 | 54 ++++++++++++++++++++++- src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC01_006/ov_SC01_006_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_003/ov_SC02_003_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_015/ov_SC03_015_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_119/ov_SC03_119_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC03_126/ov_SC03_126_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_008/ov_SC04_008_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_019/ov_SC04_019_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC04_021/ov_SC04_021_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_009/ov_SC05_009_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC05_019/ov_SC05_019_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC07_006/ov_SC07_006_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC07_007/ov_SC07_007_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC07_010/ov_SC07_010_jr_8015C32C.c | 54 ++++++++++++++++++++++- src/ov_SC07_011/ov_SC07_011_jr_8015C32C.c | 54 ++++++++++++++++++++++- 137 files changed, 7261 insertions(+), 137 deletions(-) diff --git a/src/ov_SC01_000/ov_SC01_000_jr_8015C32C.c b/src/ov_SC01_000/ov_SC01_000_jr_8015C32C.c index 26c23acfe..3f2211218 100644 --- a/src/ov_SC01_000/ov_SC01_000_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c b/src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c index fb3a9dabf..38d556901 100644 --- a/src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c b/src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c index c2a81fade..a77988429 100644 --- a/src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c b/src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c index 046424afb..c83d7cd26 100644 --- a/src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC01_006/ov_SC01_006_jr_8015C32C.c b/src/ov_SC01_006/ov_SC01_006_jr_8015C32C.c index c0665b238..b4f21c7b6 100644 --- a/src/ov_SC01_006/ov_SC01_006_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c b/src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c index b10aa8d9e..3e0679190 100644 --- a/src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c b/src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c index a25013548..62140ba5e 100644 --- a/src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c b/src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c index 3bf60b563..47e90069e 100644 --- a/src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c b/src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c index 15ca93910..2161bde28 100644 --- a/src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c b/src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c index 80740d5a8..888eecf57 100644 --- a/src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c b/src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c index db67806c7..c51e91537 100644 --- a/src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_003/ov_SC02_003_jr_8015C32C.c b/src/ov_SC02_003/ov_SC02_003_jr_8015C32C.c index 7b558e92e..6386d5071 100644 --- a/src/ov_SC02_003/ov_SC02_003_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c b/src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c index 7840e0118..2ac7527cb 100644 --- a/src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c b/src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c index d1018d37a..a7f0cb1f0 100644 --- a/src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c b/src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c index bbeb316d2..688dda200 100644 --- a/src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c b/src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c index 63a77f6dd..0937d3d24 100644 --- a/src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c b/src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c index 1614600aa..53b8dcc3b 100644 --- a/src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c b/src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c index 97ccb3f63..b87374d83 100644 --- a/src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c b/src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c index c259ca072..ebc17762d 100644 --- a/src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c b/src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c index 451e8507b..d6cc97030 100644 --- a/src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c b/src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c index bfa381998..a1a5aa480 100644 --- a/src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c b/src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c index 0715a8fc3..956e54ca0 100644 --- a/src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c b/src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c index dd4c86201..15fea754e 100644 --- a/src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c b/src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c index ab1a4b023..a9a559ff5 100644 --- a/src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c b/src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c index 60962172e..9f54b9bae 100644 --- a/src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c b/src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c index b4b7393cf..1092ef737 100644 --- a/src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c b/src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c index 896a899d4..c4018b153 100644 --- a/src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c b/src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c index fe90e3603..d3f8154f3 100644 --- a/src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c b/src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c index 97b1cafc0..f2bc053ff 100644 --- a/src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c b/src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c index f0a30d01b..5baeb1437 100644 --- a/src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c b/src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c index 42039d6c2..b0c3878d2 100644 --- a/src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c b/src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c index 58223d796..4f09b1300 100644 --- a/src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c b/src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c index 272bb5f65..be1b72474 100644 --- a/src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c b/src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c index b1460c950..c98d12ebb 100644 --- a/src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c b/src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c index eabf55882..6fd4ee911 100644 --- a/src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c b/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c index 08564d706..7a2047923 100644 --- a/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.c b/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.c index e22b82402..5e53b0673 100644 --- a/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c b/src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c index 73db8dffa..69c5f472e 100644 --- a/src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c b/src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c index 3cd71e48f..b81b6ec4b 100644 --- a/src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c b/src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c index 11edcb578..333edc605 100644 --- a/src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c b/src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c index 8d3fbd114..51935dd93 100644 --- a/src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c b/src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c index 6a88dcedc..c7a9ae9f6 100644 --- a/src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c b/src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c index c9a8b4f47..5d1184314 100644 --- a/src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c b/src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c index 3291dcc51..d4177e155 100644 --- a/src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c b/src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c index 24a10f5a4..fb542f24c 100644 --- a/src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c b/src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c index e1a2b8d8d..a84d28117 100644 --- a/src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c b/src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c index 857814321..ee1fea639 100644 --- a/src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c b/src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c index 593b57215..b55093517 100644 --- a/src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c b/src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c index 154dd4496..b6d5475e7 100644 --- a/src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c b/src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c index 626a7cf6b..b46ea7251 100644 --- a/src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c b/src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c index b496921bc..8139ec333 100644 --- a/src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c b/src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c index 9e9cabf38..5838ef958 100644 --- a/src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c b/src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c index 69ceada74..5ff239b67 100644 --- a/src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c b/src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c index 5fc7523e6..3ba638681 100644 --- a/src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c b/src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c index 043a8a7b3..f5e0dc39d 100644 --- a/src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c b/src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c index 4d16b15c0..5854208a3 100644 --- a/src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c b/src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c index b77a09dd9..5114ca2fc 100644 --- a/src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c b/src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c index 4e84597d7..b16e7db97 100644 --- a/src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c b/src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c index 908f7a38f..d3ba6c6ec 100644 --- a/src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c b/src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c index 24d4f0f80..d4ea23903 100644 --- a/src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c b/src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c index 40f69863a..28e363f70 100644 --- a/src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c b/src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c index 9b2adb38b..4a2014d72 100644 --- a/src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c b/src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c index 7fe9b92e0..8ea7f7828 100644 --- a/src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c b/src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c index 809c16d87..7223b8231 100644 --- a/src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c b/src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c index b6c4b77e7..9dc441e0b 100644 --- a/src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c b/src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c index 27d54d826..82aba1d9a 100644 --- a/src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c b/src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c index 06b0ff548..376458877 100644 --- a/src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c b/src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c index 2dc297773..77a4996e2 100644 --- a/src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c b/src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c index 4de31963c..eefb6385e 100644 --- a/src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c b/src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c index c57fdbcd3..6ec0a9648 100644 --- a/src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c b/src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c index 88f9a3071..8565f9e0d 100644 --- a/src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_119/ov_SC03_119_jr_8015C32C.c b/src/ov_SC03_119/ov_SC03_119_jr_8015C32C.c index 2c63a3f17..f3c43b8b9 100644 --- a/src/ov_SC03_119/ov_SC03_119_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c b/src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c index fcd2b3108..5a4ba8c93 100644 --- a/src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c b/src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c index 82e237574..a969ea238 100644 --- a/src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c b/src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c index 1618cebcb..32e5c9691 100644 --- a/src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC03_126/ov_SC03_126_jr_8015C32C.c b/src/ov_SC03_126/ov_SC03_126_jr_8015C32C.c index cd6dda1c5..d94c799aa 100644 --- a/src/ov_SC03_126/ov_SC03_126_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c b/src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c index dfc8eac0b..831501976 100644 --- a/src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c b/src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c index 5fe77b78f..a4be3bcb2 100644 --- a/src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c b/src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c index a3943693d..7e80f24b0 100644 --- a/src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c b/src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c index 3aafa2808..75c009a6d 100644 --- a/src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c b/src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c index 0d11552ef..910b35dfb 100644 --- a/src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c b/src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c index 00f877a7a..eafc965e0 100644 --- a/src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c b/src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c index 32defb41a..6c8c60301 100644 --- a/src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_008/ov_SC04_008_jr_8015C32C.c b/src/ov_SC04_008/ov_SC04_008_jr_8015C32C.c index cf98e66b6..6a761fc5d 100644 --- a/src/ov_SC04_008/ov_SC04_008_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c b/src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c index 0e1dc24a6..2f6efa5b3 100644 --- a/src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c b/src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c index 77cfc74d8..7e23ae50c 100644 --- a/src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c b/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c index 43309a669..44d00b45c 100644 --- a/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c b/src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c index 37de34a7a..6a0134c76 100644 --- a/src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c b/src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c index e625352b7..e3e5e4b02 100644 --- a/src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c b/src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c index 11a8e92ec..ecc59934a 100644 --- a/src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c b/src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c index d3cd18d23..55c13169f 100644 --- a/src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_019/ov_SC04_019_jr_8015C32C.c b/src/ov_SC04_019/ov_SC04_019_jr_8015C32C.c index 402b4613b..69c447ecf 100644 --- a/src/ov_SC04_019/ov_SC04_019_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c b/src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c index 7efed6de3..2ef023e4b 100644 --- a/src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC04_021/ov_SC04_021_jr_8015C32C.c b/src/ov_SC04_021/ov_SC04_021_jr_8015C32C.c index a6d965d80..8be6b027d 100644 --- a/src/ov_SC04_021/ov_SC04_021_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c b/src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c index f4f847b2a..1e1517d8b 100644 --- a/src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c b/src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c index 76b44348c..2a40ac735 100644 --- a/src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c b/src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c index 2b0bd2dfc..9f0315538 100644 --- a/src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c b/src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c index 2e6170533..1c7498763 100644 --- a/src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c b/src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c index 2683ba617..0edfae35b 100644 --- a/src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c b/src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c index af9b905d3..30c0a9031 100644 --- a/src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c +++ b/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) */ diff --git a/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c b/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c index 5c261bcaf..890db3dee 100644 --- a/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c +++ b/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC05_006/nonmatchings/ov_SC05_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) */ diff --git a/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c b/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c index 9eefff91f..9ab9797bb 100644 --- a/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c +++ b/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_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) */ diff --git a/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c b/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c index b9f070660..74bac28b3 100644 --- a/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c +++ b/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC05_008/nonmatchings/ov_SC05_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) */ diff --git a/src/ov_SC05_009/ov_SC05_009_jr_8015C32C.c b/src/ov_SC05_009/ov_SC05_009_jr_8015C32C.c index d8304af27..d0565f4ef 100644 --- a/src/ov_SC05_009/ov_SC05_009_jr_8015C32C.c +++ b/src/ov_SC05_009/ov_SC05_009_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC05_009/nonmatchings/ov_SC05_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) */ diff --git a/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c b/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c index 7550a9271..e23457d02 100644 --- a/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c +++ b/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_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) */ diff --git a/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c b/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c index c48a08f34..4a147a9a4 100644 --- a/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c +++ b/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC05_011/nonmatchings/ov_SC05_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) */ diff --git a/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c b/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c index cb3bcd86e..f331fe83c 100644 --- a/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c +++ b/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC05_017/nonmatchings/ov_SC05_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) */ diff --git a/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c b/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c index e6e54b909..06e080aed 100644 --- a/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c +++ b/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC05_018/nonmatchings/ov_SC05_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) */ diff --git a/src/ov_SC05_019/ov_SC05_019_jr_8015C32C.c b/src/ov_SC05_019/ov_SC05_019_jr_8015C32C.c index c046fe930..4caa01add 100644 --- a/src/ov_SC05_019/ov_SC05_019_jr_8015C32C.c +++ b/src/ov_SC05_019/ov_SC05_019_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC05_019/nonmatchings/ov_SC05_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) */ diff --git a/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c b/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c index 9bdef6369..0fb8e0f89 100644 --- a/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c +++ b/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_000/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c b/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c index d8fc6cb86..5209d0233 100644 --- a/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c +++ b/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_006/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c b/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c index 37cd241f8..9301c58e6 100644 --- a/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c +++ b/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_008/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c b/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c index ca49d9999..2f8e351d1 100644 --- a/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c +++ b/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_010/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c b/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c index 8b95bee77..8db02b747 100644 --- a/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c +++ b/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_011/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c b/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c index e53e3cf9c..01cd92fcd 100644 --- a/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c +++ b/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_013/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c b/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c index 21130ee48..1a29d5b11 100644 --- a/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c +++ b/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_014/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c b/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c index 176e00694..b0567e285 100644 --- a/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c +++ b/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_015/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c b/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c index fe4891e38..b6a6fb0b5 100644 --- a/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c +++ b/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c b/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c index 68f83d3f0..39476e4cd 100644 --- a/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c +++ b/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_018/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c b/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c index c0c0946d2..b68fed52d 100644 --- a/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c +++ b/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_020/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c b/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c index 58b9a8539..d0f545f59 100644 --- a/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c +++ b/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_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) */ diff --git a/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c b/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c index 3a9854849..c25425d3d 100644 --- a/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c +++ b/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c b/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c index 477f230da..a0164354d 100644 --- a/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c +++ b/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_025/nonmatchings/ov_SC06_025_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) */ diff --git a/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c b/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c index 20d102b0a..30285fc61 100644 --- a/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c +++ b/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_027/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c b/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c index 72f63ffc1..b2e3fb790 100644 --- a/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c +++ b/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_029/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c b/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c index 70f752421..321fc5ccc 100644 --- a/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c +++ b/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_030/nonmatchings/ov_SC06_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) */ diff --git a/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c b/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c index f1168990a..f7a4539ce 100644 --- a/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c +++ b/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_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) */ diff --git a/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c b/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c index 880956525..17874eda6 100644 --- a/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c +++ b/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_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) */ diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c b/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c index faf4a2ed4..cb363f456 100644 --- a/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c +++ b/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_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) */ diff --git a/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c b/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c index 05c885403..341a9af87 100644 --- a/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c +++ b/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC07_001/nonmatchings/ov_SC07_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) */ diff --git a/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c b/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c index 9a027301c..3b0bd56de 100644 --- a/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c +++ b/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC07_002/nonmatchings/ov_SC07_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) */ diff --git a/src/ov_SC07_006/ov_SC07_006_jr_8015C32C.c b/src/ov_SC07_006/ov_SC07_006_jr_8015C32C.c index 87727d4a4..f5f9c6011 100644 --- a/src/ov_SC07_006/ov_SC07_006_jr_8015C32C.c +++ b/src/ov_SC07_006/ov_SC07_006_jr_8015C32C.c @@ -4509,7 +4509,59 @@ int func_80161888(int param_1, unsigned int param_2) } -INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_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) */ diff --git a/src/ov_SC07_007/ov_SC07_007_jr_8015C32C.c b/src/ov_SC07_007/ov_SC07_007_jr_8015C32C.c index 2bbcb7a13..28de33906 100644 --- a/src/ov_SC07_007/ov_SC07_007_jr_8015C32C.c +++ b/src/ov_SC07_007/ov_SC07_007_jr_8015C32C.c @@ -4461,7 +4461,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_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) */ diff --git a/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c b/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c index e761cd7e7..874e1f792 100644 --- a/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c +++ b/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC07_008/nonmatchings/ov_SC07_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) */ diff --git a/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c b/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c index 306668cef..833f8357e 100644 --- a/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c +++ b/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c @@ -3466,7 +3466,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC07_009/nonmatchings/ov_SC07_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) */ diff --git a/src/ov_SC07_010/ov_SC07_010_jr_8015C32C.c b/src/ov_SC07_010/ov_SC07_010_jr_8015C32C.c index dc6d4609c..e068bffe1 100644 --- a/src/ov_SC07_010/ov_SC07_010_jr_8015C32C.c +++ b/src/ov_SC07_010/ov_SC07_010_jr_8015C32C.c @@ -3888,7 +3888,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_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) */ diff --git a/src/ov_SC07_011/ov_SC07_011_jr_8015C32C.c b/src/ov_SC07_011/ov_SC07_011_jr_8015C32C.c index 126f295b7..c64943cba 100644 --- a/src/ov_SC07_011/ov_SC07_011_jr_8015C32C.c +++ b/src/ov_SC07_011/ov_SC07_011_jr_8015C32C.c @@ -4462,7 +4462,59 @@ int func_80161888(int param_1, unsigned int param_2) { } -INCLUDE_ASM("asm/ov_SC07_011/nonmatchings/ov_SC07_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) */