From 8bc06a2cb891bcc6f1ff15ff1342ea74b5218a58 Mon Sep 17 00:00:00 2001 From: Drew T <50529377+Druthulu@users.noreply.github.com> Date: Thu, 10 Sep 2026 18:17:41 -0600 Subject: [PATCH] =?UTF-8?q?phase-36:=20T7=20agent=20c42=20=E2=80=94=20func?= =?UTF-8?q?=5F80186A8C=20and=20func=5F80182058=20closed=20through=20cross-?= =?UTF-8?q?jump=20readings=20(10=20bodies);=20related.txt=20requires=20evi?= =?UTF-8?q?dence=20before=20calling=20a=20same-name=20body=20a=20variant?= =?UTF-8?q?=20(R22=20218/218)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../agents/ov_SC03_001__func_80182058/body.c | 15 +- .../ov_SC03_001__func_80182058/mechanism.md | 71 + .../ov_SC03_091__func_80186A8C/mechanism.md | 2 +- .../agents/ov_SC03_102__func_80183E3C/body.c | 74 + .../agents/ov_SC04_011__func_80177B5C/body.c | 5 +- .../agents/ov_SC04_011__func_8017D000/body.c | 19 +- .../ov_SC04_011__func_8017D000/mechanism.md | 88 + .../agents/ov_SC06_022__func_80185578/body.c | 47 + .../ov_SC06_022__func_80185578/body_tu.c | 8619 +++++++++++++++++ .../ov_SC06_022__func_80185578/mechanism.md | 75 + .run/P36/census/lever_census.json | 70 +- .run/P36/census/lever_census.txt | 28 +- .run/P36/delever/calibration.json | 354 +- .run/P36/delever/ledger.jsonl | 10 + .../corpus/tools/P10/delever_pack.py | 9 +- docs/lever-progress.tsv | 1 + docs/levers.md | 5 +- phase-ends/CURRENT_PHASE.md | 10 + src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c | 20 +- src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c | 32 +- src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c | 20 +- src/ov_SC03_091/ov_SC03_091_jr_8018326C.c | 20 +- src/ov_SC03_094/ov_SC03_094_jr_8017BEBC.c | 20 +- src/ov_SC03_098/ov_SC03_098_jr_8017D898.c | 20 +- src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c | 16 +- src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c | 16 +- src/ov_SC05_017/ov_SC05_017_jr_801808D4.c | 16 +- tools/delever_pack.py | 9 +- 28 files changed, 9326 insertions(+), 365 deletions(-) create mode 100644 .run/P36/agents/ov_SC03_001__func_80182058/mechanism.md create mode 100644 .run/P36/agents/ov_SC03_102__func_80183E3C/body.c create mode 100644 .run/P36/agents/ov_SC04_011__func_8017D000/mechanism.md create mode 100644 .run/P36/agents/ov_SC06_022__func_80185578/body.c create mode 100644 .run/P36/agents/ov_SC06_022__func_80185578/body_tu.c create mode 100644 .run/P36/agents/ov_SC06_022__func_80185578/mechanism.md diff --git a/.run/P36/agents/ov_SC03_001__func_80182058/body.c b/.run/P36/agents/ov_SC03_001__func_80182058/body.c index 65271b205..2ef079d59 100644 --- a/.run/P36/agents/ov_SC03_001__func_80182058/body.c +++ b/.run/P36/agents/ov_SC03_001__func_80182058/body.c @@ -7,10 +7,6 @@ s32 func_80182058(void *a0) u16 st; if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) { - /* LOAD-BEARING zero-byte cross-jump barrier (cookbook §5a). - * Without it gcc's find_cross_jump merges this `move v0,0; j epi` - * tail with the identical case-2 failure tail -> 58 ins instead of - * 60, and the case-2 `beq` then loses its delay-slot fill. */ return 0; } @@ -21,13 +17,13 @@ s32 func_80182058(void *a0) *(s16 *)((s32)p + 0x2) = 8; break; case 2: - if (*(u16 *)((s32)p + 0x34) != 1) { - return 0; + if (*(u16 *)((s32)p + 0x34) == 1) { + goto hit; } - goto hit; + goto fail; case 4: if (*(u16 *)((s32)p + 0x34) != 0) { - return 0; + goto fail; } hit: D_801EEAF0 = st; @@ -35,6 +31,9 @@ s32 func_80182058(void *a0) *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10; break; default: + fail: /* the case-2/case-4 failures share this one `return 0`: a return + * falling out of a conditional (as the first one does) is what + * jump2's cross-jump would merge the early return into */ return 0; } diff --git a/.run/P36/agents/ov_SC03_001__func_80182058/mechanism.md b/.run/P36/agents/ov_SC03_001__func_80182058/mechanism.md new file mode 100644 index 000000000..8ed45dd5f --- /dev/null +++ b/.run/P36/agents/ov_SC03_001__func_80182058/mechanism.md @@ -0,0 +1,71 @@ +# func_80182058 (ov_SC03_001_jr_8017AE2C.c) — T7 agent c42 — score 10 -> 0, the barrier gone + +## (a) The residual in one sentence +COUNT 58 vs 60: the early `if (func_8012BD14(..) > 0x4000) return 0;` block (`j epi / move v0,zero`) is missing — mine +branches `beqz v0` into the case-2 failure's `v0 = 0; j epi` block instead, and that block, now a join, loses the +`move v0,zero` fill of the case-2 `beq` delay slot (a `nop` there). Every `j` offset after it shifts by 8. + +## (b) The pass and the decision (read, then proven on `scratch/dumps_free`, `dumps_tree`, `dumps_w2` — `.greg` vs `.jump2`) +Post-reload cross-jumping (`toplev.c:3142` `jump_optimize (insns, 1, 1, 0)`; `jump.c:1969-2000` simple jumps tried +against every other jump to the same label, in chain order; `find_cross_jump` `jump.c:2371`, minimum 2). +Every `return 0` is `(set v0 0)` + `(jump epi)`. Before jump2 the lever-free body has FOUR such blocks: A (the early +return), B (case-2 failure), C (case-4 failure), D (the `default:`). A and C FALL OUT OF A CONDITIONAL JUMP whose label is +right after them. A is processed first; against B: `v0=0` matches (1 insn, minimum 2->1), then both streams reach a +JUMP_INSN (A's `if` jump 18 vs B's `beq` 54) that differ — and because jump 18's label follows A's own jump, the +jump-around-jump discount fires (`jump.c:2516-2519`, `prev_real_insn (JUMP_LABEL (i1)) == e1`): minimum 0, A is MERGED +INTO B (dumps_free `fn.jump2`: label 156 in front of B's insn 58, jump 18 retargeted there; C and D follow). +The target (= the tree's barrier body, dumps_tree) merges everything INTO A instead: the asm insn before A's `v0=0` makes +A's backward walk stop on an INSN-vs-JUMP code mismatch (`jump.c:2412`, no discount), so A finds no partner; D, +preceded by its own label, then merges into A through the label discount (`jump.c:2406-2410`), and B follows once it is +labelled. A survives in place, B becomes `beq hit / j A'` and reorg fills exactly as the target. + +## (c) The move that closed it (10 -> 0, byte-proven) +Route the case-2 and case-4 failures to the `default:` block's `return 0` instead of returning in place: + + case 2: + if (*(u16 *)((s32)p + 0x34) == 1) { + goto hit; + } + goto fail; + case 4: + if (*(u16 *)((s32)p + 0x34) != 0) { + goto fail; + } + hit: ... + break; + default: + fail: + return 0; + +Now only TWO `v0=0; j epi` blocks reach jump2 (dumps_w2 `fn.greg`): A (after its conditional) and `fail` (after a +barrier + label). A vs fail: 1 match, then JUMP_INSN vs BARRIER (the stream-2 walk skips the label) -> code mismatch, +no discount, no merge. fail vs A: 1 match + its own label -> minimum 0 -> `fail` merged into A (dumps_w2 `fn.jump2`: +new `code_label 150` before A's insn 22, jumps 115/121/62/70 all retargeted to 150). The target's jump graph exactly. +No asm, no pin, no volatile, no invented term; the stale "LOAD-BEARING barrier" comment is dropped (refuted). + +## (d) GENERATOR PROPOSAL +When a `__asm__ __volatile__("")` cross-jump barrier sits before an early `if (..) return K;` and several OTHER +`return K;` statements also fall out of conditionals (`if (..) return K;` inside switch cases / if-chains), rewrite those +others as `goto fail;` to ONE labelled `return K;` (the switch `default:` if it already returns K, else a new label after +the last statement): a labelled block can only be merged INTO the early return (label discount, `jump.c:2406`), never the +reverse, while fall-out-of-conditional returns carry the jump-around-jump discount (`jump.c:2518`) that lets the FIRST +return in insn order be merged away. Keep each branch's polarity: `if (ok) goto hit; goto fail;` (w1's +`if (!ok) goto fail; goto hit;` scores 2 — the `beq`/`bne` inverts). + +## (e) What did NOT work (byte evidence) +* w1 (`if (x != 1) goto fail; goto hit;` in case 2): 2 — right jump graph, inverted case-2 branch (`bne ..,epi` + `j hit`). +* w4 (case 2 via `fail`, case 4 keeps `return 0;`): 11 — C is still a fall-out-of-conditional return; A merges into C. +* w6 (`fail:` as a trailing `return 0;` after the final return, default keeps its own): 11 — A merges again. +* w3 (switch restructured so failures `break` to a `return 0` after the switch, successes `goto done`): 12 — layout moves. +* The mechanical search (646 compiles, R7/R8/R10) has no move that re-targets a `return` to a shared label. + +## (f) Where the method fell short +* The METHOD's cross-jump entries (c6/c10/c15) speak of merges the target keeps apart and of SHAPES made to differ; this + one is about merge DIRECTION: the same two blocks merge either way, and which survives is decided by which one owns + the discount (`jump.c:2406` label vs `:2518` jump-around-jump) and by insn order. Reading `.greg` (pre-jump2) against + `.jump2` for the surviving `code_label` settled it in one comparison — worth a METHOD line: "for a cross-jump + residual, find the SURVIVOR label in `.jump2` for both the tree body and yours". +* The TU/comment note ("LOAD-BEARING zero-byte cross-jump barrier (cookbook §5a)") was a claim; refuted on bytes. + +Paths: body `.run/P36/agents/ov_SC03_001__func_80182058/body.c`; dumps `scratch/dumps_free/`, `scratch/dumps_tree/`, +`scratch/dumps_w2/`; variants `scratch/w1..w6.c`. diff --git a/.run/P36/agents/ov_SC03_091__func_80186A8C/mechanism.md b/.run/P36/agents/ov_SC03_091__func_80186A8C/mechanism.md index 42394347c..d5b857759 100644 --- a/.run/P36/agents/ov_SC03_091__func_80186A8C/mechanism.md +++ b/.run/P36/agents/ov_SC03_091__func_80186A8C/mechanism.md @@ -6,7 +6,7 @@ Same 230 instructions; at both `func_8012B178(a0, t - 0x4000)` sites the target COUNT: 230 = 230, nothing missing — a pure ORDER residual of two insns, twice. ## (b) The passes and decisions (read, then proven on dumps `scratch/dumps_free`, `scratch/dumps_v1`) -* `calls.c:1879-1889` (gcc-2.7.2): MIPS has no `PUSH_ROUNDING`, so `PUSH_ARGS_REVERSED` is NOT defined (`calls.c:38-44`); the +* `calls.c:1860-1881` (gcc-2.7.2): MIPS has no `PUSH_ROUNDING`, so `PUSH_ARGS_REVERSED` is NOT defined (`calls.c:38-44`); the hard-register loads are emitted in argument order, `$4 = a0` then `$5 = value` (dumps_free `fn.rtl` insns 163, 165). * combine (`can_combine_p`, `combine.c:880-930`): the separate `av = t - 0x4000` insn (160) is folded into the `$5 = av` arg-move (165), which sits AFTER `$4 = a0` — so the subtract becomes the last insn before the call (dumps_free `fn.combine`). diff --git a/.run/P36/agents/ov_SC03_102__func_80183E3C/body.c b/.run/P36/agents/ov_SC03_102__func_80183E3C/body.c new file mode 100644 index 000000000..ee6c6d9a0 --- /dev/null +++ b/.run/P36/agents/ov_SC03_102__func_80183E3C/body.c @@ -0,0 +1,74 @@ +void func_80183E3C(s32 a0) { + + extern u8 D_800AF648; + extern s32 D_801A73BC; + extern s32 D_8019989C; + extern s32 D_80199B70; + extern u16 D_80126B62; + /* sp+0x10 local block. Frame is 0x38 = 0x10 outgoing args + 0x20 vars + + * 8 saved regs ($s0,$ra), so the vars block is 12 bytes larger than the + * fields this function actually touches -> trailing `unused[3]`. */ + struct { + s16 v[3]; /* sp+0x10 */ + s16 pad0; /* sp+0x16 */ + u16 sxy[2]; /* sp+0x18 */ + s32 z; /* sp+0x1C */ + s32 flag; /* sp+0x20 */ + s32 unused[1]; /* sp+0x24 */ + } L; + s16 x; + s32 y; + + if (*(s32 *)(a0 + 0x94) == 0xD) { + L.v[0] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x48); + L.v[1] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x4C); + L.v[2] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x50); + /* The target loads &D_800AF648 afresh (lui/addiu $a0) for EACH call. The + * second call names the object through a second declaration of the same + * symbol: its SYMBOL_REF string is a different pointer, so cse does not + * unify the two address pseudos into one callee-saved register. */ + func_8004914C(&D_800AF648); + { + extern u8 D_800AF648_b __asm__("D_800AF648"); + func_800491AC(&D_800AF648_b); + } + RotTransPers((s32)L.v, (s32)L.sxy, &L.z, &L.flag); + if (L.flag >= 0 && (u32)((L.sxy[0] + 0x9F) & 0xFFFF) < 0x13F + && (u32)((L.sxy[1] + 0x77) & 0xFFFF) < 0xEF) { + s32 vol = (s16)L.sxy[0]; + if (vol < 0) { + vol = -vol; + } + vol = ((0xA0 - vol) * 127) / 160; + func_8002D4C8(0x702, (vol | 0x1000) & 0xFFFF); + } + } + + if (func_8012BCCC(a0) <= 0x24000) { + s16 c; + c = *(u16 *)(a0 + 0x102) + 1; + *(s16 *)(a0 + 0x102) = c; + if (c >= 0x78) { + if ((*(u16 *)(a0 + 0x100) & 0x2000) == 0) { + func_8012A828(a0, (s32)&D_801A73BC); + *(s16 *)(a0 + 0x2) = 10; + *(s16 *)(a0 + 0x102) = 0; + *(s32 *)(a0 + 0x58) = (s32)&D_8019989C | 0x40000000 | 0x20000000; + } + } + } + + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) += func_8012B8E4(a0, 0x10); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) &= 0xFFF; + + x = *(s16 *)(a0 + 0xA); + y = *(s16 *)&D_80126B62; + if (x <= y - 0x100) { + *(s16 *)(a0 + 0xA) = x + 0x8; + } else if (x >= y - 0x80) { + *(s16 *)(a0 + 0xA) = x - 0x8; + } + + func_8012B1B4(a0, (s32)&D_80199B70); + func_8012CBCC(a0); +} diff --git a/.run/P36/agents/ov_SC04_011__func_80177B5C/body.c b/.run/P36/agents/ov_SC04_011__func_80177B5C/body.c index 0c02f3f37..727b3d5a6 100644 --- a/.run/P36/agents/ov_SC04_011__func_80177B5C/body.c +++ b/.run/P36/agents/ov_SC04_011__func_80177B5C/body.c @@ -33,6 +33,7 @@ s16 y; u32 c; u16 bb; u32 c0; + u32 w; mk1 = 0xFFFFFF; cc1 = 0x74808080; @@ -50,10 +51,12 @@ s16 y; yt = y; c0 = yt + 1; c0 <<= 16; + w = c0 | x1; + __asm__("" : "=r"(w) : "0"(w)); // !FAKE: launder w — sched1 launches a single-set p[2] value right before its store (birthing_insn_p, sched.c:2469) and sched2 ties the or/ori at equal priority and falls back to sched1's order (sched.c:2385); the asm's second set of w keeps it ahead of the cl chain, no plain spelling reorders them (S103 c19) (P36 S103 c46 minimum-lever) c = v << 6; c |= 0x4016; cl = c << 16; - p[2] = c0 | x1; + p[2] = w; p[3] = cl | 0x1800; p += 5; p[0] = (((u32)(p - 5)) & mk1) | ca; diff --git a/.run/P36/agents/ov_SC04_011__func_8017D000/body.c b/.run/P36/agents/ov_SC04_011__func_8017D000/body.c index 5dc6ae486..d48f1407d 100644 --- a/.run/P36/agents/ov_SC04_011__func_8017D000/body.c +++ b/.run/P36/agents/ov_SC04_011__func_8017D000/body.c @@ -35,7 +35,7 @@ void func_8017D000(void *a0) { s32 t; s16 *p; - void *w; + s16 *r; if (cur != lo) { if (lo < cur) { @@ -72,7 +72,7 @@ void func_8017D000(void *a0) { if (*(s16 *)((s32)a0 + 0xFC) == 0xB) { s32 f = *(s32 *)((s32)a0 + 0x1C); - s32 v = -(f & 1) & 0xC0; + u8 v = -(f & 1) & 0xC0; f = f + 1; *(s32 *)((s32)a0 + 0x1C) = f; D_801EED51 = v; @@ -100,6 +100,7 @@ void func_8017D000(void *a0) { u16 bs; s32 x; s16 y; + s16 *s; t = (c - h) * 255 / h; q = &D_801EED4D; bs = (u16)D_801EED28; @@ -107,7 +108,8 @@ void func_8017D000(void *a0) { y = x - 4; D_801EED55 = 0xFF; *q = 0xFF; - *(s16 *)(q + 0xF) = x; + s = (s16 *)(q + 0xF); + *s = x; D_801EED64 = bs + c; D_801EED30 = x; D_801EED6C = y; @@ -115,14 +117,13 @@ void func_8017D000(void *a0) { D_801EED74 = bs + c - 4; D_801EED88 = -t; D_801EED80 = -t; - func_800176F0(q + 0xF); + func_800176F0(s); } p = &D_801EEDA8; - D_801EED98 = *(u16 *)((s32)p - 0x18) + (u16)D_80193E88; + r = p - 0xC; + D_801EED98 = *(u16 *)r + (u16)D_80193E88; *p = D_801EED98 - 4; - w = (void *)((s32)p - 0x80); - p = (s16 *)((s32)p - 0x18); - func_800176F0(w); - func_800176F0(p); + func_800176F0(p - 0x40); + func_800176F0(r); } diff --git a/.run/P36/agents/ov_SC04_011__func_8017D000/mechanism.md b/.run/P36/agents/ov_SC04_011__func_8017D000/mechanism.md new file mode 100644 index 000000000..ba0c3d0e3 --- /dev/null +++ b/.run/P36/agents/ov_SC04_011__func_8017D000/mechanism.md @@ -0,0 +1,88 @@ +# func_8017D000 (ov_SC04_011, TU ov_SC04_011_jr_8017AE2C.c) — T7 agent c44 + +**Result: score 0, lever-free.** No register pin, no asm, no added volatile, no do-while, no invented term, no dead +assignment. The fix is inside the function body only. Whole-object check on the `--try --keep` object: `objdump -drz` of the +ENTIRE `.o` (every function, relocations included) is identical to `.run/P36/delever/baseline/src/ov_SC04_011/ +ov_SC04_011_jr_8017AE2C.o`, and `.text` compares equal with `cmp`. Candidates are in `scratch/` (`a1.c`, `b1.c`, `c1.c`, +`d1.c` = `body.c`, `e1.c`) with their `.dis`; the pass dumps are in `scratch/dumps_free/` and `scratch/dumps_d1/`. + +No lever-free copy existed elsewhere: `git grep` finds no other definition that touches `D_801EEDA8`, and +`related.txt` listed no port candidate (the only `func_8017D000` in `src/shared/ov/` is an unrelated function with the same +overlay address). + +## (a) The residual in one sentence + +COUNT 296 vs 293. There were three independent defects. (1) In the `== 0xB` arm, `f` and `v` had swapped registers and +`f + 1; sw` was hoisted above `negu; andi 0xc0`. (2) In the else arm, `*(s16 *)(q + 0xF) = x` became an absolute +`lui at; sh v0,15(at)` (+1) where the target writes `sh v0,15(a2)`. As a result `addiu a0,a2,15` left the `jal` delay +slot (+1 `nop`). (3) In the tail, `*(u16 *)(p - 0x18)` became an absolute `lui v0; lhu v0,-24(v0)` (+1) where the target +reads `lhu v0,-24(s0)`. + +## (b) The passes and the decisions (all three proven on bytes and in dumps) + +### Defects 2 and 3: cse folds a base+offset MEM address into an absolute address. A register address is not folded. + +* `find_best_addr` (cse.c:2621). An address that is not a bare REG is first run through `fold_rtx` and accepted by + `validate_change` with NO cost test (cse.c:2659-2662). `p` / `q` carry the constant equivalence `&SYM`, so + `(plus p -24)` folds to `(const (plus SYM -24))`, which is a valid MIPS address (the assembler's `lui at` macro). This is + why the tree needed the three launders. +* A BARE REG address skips that fold. For a REG, cse looks up the register's equivalence class and takes the member with + the lowest `ADDRESS_COST`, breaking ties by the higher `rtx_cost` (cse.c:2708-2735). `ADDRESS_COST(REG)=1` + (mips.h:2895), `(plus reg small_int)`=1, and `(const (plus sym k))`=2 (`mips_address_cost`, mips.c:1615-1653). So + for `s = q + 15; *s = x;` the class of `s` is {`s`, `(plus q 15)`, `(const D_801EED4D+15)`}. The tie at cost 1 goes to + `(plus q 15)` (the higher rtx_cost). The constant, at cost 2, is never chosen. Dump proof: `dumps_d1/d1.i.rtl` insn 433 + is `(set (mem:HI (reg 240)) …)`, and `d1.i.cse` rewrites it as `(set (mem:HI (plus (reg 236) 15)) …)`. The tail + behaves the same way: insn 485 becomes `(mem:HI (plus (reg 86) -24))`. +* After that, the pointer temp's only other use is the call argument. The `(set s (plus q 15))` insn stays where the + source put it, just before the call (it is kept as a PLUS because `rtx_cost` of the CONST is higher). So reorg puts + `addiu a0,a2,15` back into the `jal` delay slot, and the tail's `r` ties to `p`'s `$s0` (`addiu s0,s0,-24` in the + first `jal`'s delay slot), as in the target. + +### Defect 1: sched1's `birthing_insn_p` boost. The `u8` width removes it. + +* With `s32 v`, the last insn of the chain (`v = t & 0xC0`) is a SET of a REG that is live after it and set only once. + `birthing_insn_p` (sched.c:2468-2499) returns 1 for it, and `adjust_priority` (sched.c:2539-2545) raises it to + `max_priority` when it becomes ready in the backward list scheduler. So the `v` chain is placed right before its first + `sb`, and `f + 1; sw` is scheduled above `negu/andi` (`dumps_free/free.i.lreg`: order 255 257 **262 265** 258 259 268). +* With `u8 v` (the width of every destination it is stored to), combine folds the truncating move into the `and`, and + that insn's destination becomes `(subreg:SI (reg:QI 191) 0)`. `birthing_insn_p` wants `GET_CODE (SET_DEST) == REG`, + so it gets no boost, and sched1 keeps source order: 255 259 262 269 272 275 278 (`dumps_d1/d1.i.sched`). Local-alloc + then gives `v` `$v0` and `f` `$v1`, as in the target. This is the same fact the tree's asm launder was forcing: an asm + output is not a plain birthing SET of the chain. + +## (c) The source moves that closed it (three, independent; the scores are additive) + +1. `s32 v = -(f & 1) & 0xC0;` → `u8 v = …` (the width of the ten `u8` stores). 33 → 17 (`a1.c`). +2. Else arm: `s16 *s = (s16 *)(q + 0xF); *s = x; … func_800176F0(s);` instead of `*(s16 *)(q + 0xF) = x; … + func_800176F0(q + 0xF);`. On top of 1: 17 → 2 (`c1.c`). +3. Tail: `r = p - 0xC; D_801EED98 = *(u16 *)r + (u16)D_80193E88; *p = D_801EED98 - 4; func_800176F0(p - 0x40); + func_800176F0(r);` instead of the reassigned `p` + `w`. On top of 1: 17 → 15 (`b1.c`). 1+2+3: **0** (`d1.c`). + Control: 2+3 without 1 = 16 (`e1.c`, MIXED), so move 1 is exactly defect 1. + +## (d) GENERATOR PROPOSALS + +* **COUNT +1 `lui at` / `lui vN` on an offset load/store where the target uses `k(reg)` of a pointer that holds `&SYM`:** + name the offset address as a pointer local (`T *s = (T *)(base + k); *s = …`), and if the target also passes + `base + k` to a call, pass `s` there. cse's `find_best_addr` keeps a register address as `(plus base k)` (cost tie, + cse.c:2715-2721) but folds a written-out `base + k` to an absolute address (cse.c:2659). This is the plain-C + replacement for the `__asm__("" : "=r"(p) : "0"(p))` launder whenever the pointer's other uses are call arguments. +* **ORDER + swapped `$v0/$v1` where the target computes a value's whole chain before an unrelated `x+1; sw`:** if the + value is only stored narrow (`sb`/`sh`), declare it with the store width (`u8`/`s16`). The subreg destination stops + sched1's birthing boost (sched.c:2468-2545). Test: `.lreg` shows the chain's last insn scheduled right before its first + use. + +## (e) What did not work (byte evidence) + +* `*(s32 *)(a0 + 0x1C) = f + 1;` with `f` not reassigned: 21 (`a2.c`). Worse, because the register swap stays. +* `b1.c` (tail only, on top of move 1): 15. That fixes the tail's `lui`; the else arm's absolute `sh` + `nop` remain. +* The mechanical search's best (15, a do-while + `R8 base tmp0`) never tried a pointer local on a MEM address. Its + `R12 width t` moves narrowed `t`, not `v`. + +## (f) Where the method fell short + +* METHOD_S103's launder list (c11: "write the read relative to a DERIVED pointer") describes the case where the pointer + is NOT known constant to cse. Here the pointer IS a known constant in the same block, and the answer is simpler: + make the address itself a REGISTER. `find_best_addr` never folds a REG, only non-REG addresses (cse.c:2659 vs + :2708-2735). This should be the FIRST launder move tried: it is one line and needs no pass-ordering conditions. +* COUNT-first worked: the three extras were one `lui at`, one `nop`, and one `lui v0`, each visible only in the whole + objdump (the hunk view split the `sh 15(a2)` across two hunks). diff --git a/.run/P36/agents/ov_SC06_022__func_80185578/body.c b/.run/P36/agents/ov_SC06_022__func_80185578/body.c new file mode 100644 index 000000000..86cff27f7 --- /dev/null +++ b/.run/P36/agents/ov_SC06_022__func_80185578/body.c @@ -0,0 +1,47 @@ +s32 func_80185578(s32 arg0, s32 arg1) { + extern u8 D_801BD0C4[]; + extern s32 D_801BD2FC[]; + extern u8 D_800D3918[]; + extern void func_80187414(s32 a0, void *a1, void *a2, s32 a3); + extern void func_801873B0(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5); + extern void func_8001C924(s32 a0, void *a1); + u8 buf[8]; + s16 y = arg1; + s32 res; + s16 state; + s32 flags; + + state = *(u16 *)(arg0 + 0x70) & 0xF; + flags = *(u32 *)(arg0 + 0xE0); + if (flags & 4) { + return 0; + } + switch (state) { + case 0: + if (flags & 1) { + func_80187414(arg0, D_801BD0C4, buf, 0xC); + res = ((s32 (*)(s32, void *, s32, s32, s32, s32))func_801873B0)(arg0, buf, 0x27F, (s16)arg1, 0, 0); + *(s32 *)(arg0 + 0xD0) = res; + *(u32 *)(arg0 + 0xE0) &= ~1; + if (res != 0) { + *(u16 *)(arg0 + 0xEE) = *(u16 *)(res + 0x36); + } + } + /* fallthrough */ + case 1: + case 2: + case 3: + func_80187414(arg0, D_800D3918, buf, 0xB); + res = ((s32 (*)(s32, void *, s32, s32, s32, s32))func_801873B0)(arg0, buf, 0x27F, (s16)(y | (state + 1)), 0, 0); + *(s32 *)(arg0 + 0xCC) = res; + *(u32 *)(arg0 + 0xE0) |= 4; + func_8001C924(*(s32 *)(arg0 + 0x20), (void *)D_801BD2FC[state]); + if (res != 0) { + *(u16 *)(arg0 + 0xEC) = *(u16 *)(res + 0x36); + } + break; + default: + return 1; + } + return 1; +} diff --git a/.run/P36/agents/ov_SC06_022__func_80185578/body_tu.c b/.run/P36/agents/ov_SC06_022__func_80185578/body_tu.c new file mode 100644 index 000000000..91e260087 --- /dev/null +++ b/.run/P36/agents/ov_SC06_022__func_80185578/body_tu.c @@ -0,0 +1,8619 @@ +#include "common.h" +#include "../shared/engine_prelude.h" + + +/* ==== Phase-26 §8b carried decl layer (jr_isolate_all.py) =================== + * The file-scope decl environment from earlier code regions of this object — + * file-local types, col-0 decls, DEFINE_func macro externs, and each earlier + * definition's implied prototype (types first, then decls in original order). + * Decls emit no code => byte-neutral. See cookbook §8c. */ +typedef struct { + SVECTOR_8016E7C8 v[4]; /* 0x00 */ + s32 f0, f1, f2, f3, f4, f5; /* 0x20..0x37 */ + u8 f6; /* 0x38 */ + u8 pad[7]; /* -> 0x40 */ +} Prim_8016E7C8; +typedef void (*Handler)(struct Entry_8016E95C *); +extern void func_801458E0(void); +extern s32 D_800AE6AC; +extern s32 D_800AE6B0; +extern s16 D_800B9A0A; +extern u8 D_80078E50; +extern void func_800D185C(u8 *a0); +extern void func_801458E8(void); +extern s32 func_80029504(void); +extern void func_80145B24(void); +extern u8 D_8018F850; +extern u8 D_8018F7C0; +extern u8 D_8018F79C; +extern u8 D_8018F778; +extern u8 D_8018F82C; +extern u8 D_8018F808; +extern u8 D_8018F7E4; +extern u8 D_8018F754; +extern void func_80145934(void); +extern u8 D_8018F8E0; +extern u8 D_8018F8BC; +extern u8 D_8018F898; +extern u8 D_8018F874; +extern void func_80145A2C(void); +extern s32 func_800291DC(s32); +extern void func_800291C8(s32, s32); +extern void func_80162120(void); +extern void func_80029124(s32, s32); +extern s32 func_80165A50(s32); +extern void func_80029514(s32); +extern u8 D_800AF630[]; +extern u8 D_80078EC0; +extern s32 func_80028FBC(void); +extern s32 func_80029000(void); +extern s32 func_80028D9C(void); +extern void func_8002D4C8(s32 a0, s32 a1); +extern void func_80145BF8(void); +extern s32 func_800291B4(s32 arg); +extern void func_800291A0(s32, s32); +extern void func_80145C54(void); +extern s32 func_80145CEC(); +extern s32 func_80029178(s32 arg); +extern void func_80146014(s32 a0); +extern unsigned char D_8018ECD8[]; +extern unsigned char D_8018ED08[]; +extern unsigned char D_8018ED58[]; +extern unsigned char D_8018ED88[]; +extern unsigned char D_8018EDB8[]; +extern void func_80145EE8(s32 param_1); +extern void MoveImage(void *a0, s32 a1, s32 a2); +extern void func_80146074(void); +extern s32 func_80146128(void); +extern void func_80146360(void); +extern void func_801463A0(); +extern void func_8014607C(void); +extern u8 D_80078EC1; +extern s32 D_80078EC8; +extern s32 D_8011F730; +extern u16 D_801152B8; +extern u16 D_8012693A; +extern u8 D_80126BE0[]; +extern u8 D_801150F0[]; +extern void *memcpy(void *dst, const void *src, u32 n); +extern void func_80146FC4(s32 a0); +extern void func_80150A70(s32 a0); +extern void func_80147098(s32 *a0); +extern void func_8014A638(s32 arg0); +extern s32 func_80155458(s32 a0); +extern s32 func_80029104(void); +extern void func_80029344(void); +extern void func_8014ADE0(s32 a0); +extern void func_8014B350(s32 a0); +extern void func_8014B7A4(s16 *param_1); +extern s32 func_80161D58(s32 a0); +extern void func_80161A90(s32 a0); +extern void func_8014B504(u16 *a0); +extern void func_80149BEC(s32 a0); +extern void func_8014B5D0(s32 *a0); +extern void func_8014C99C(u8 *a0); +extern void func_8014B190(s32 s0); +extern void func_80148648(s32 a0, s32 a1); +extern s32 func_80149228(s32 a0); +extern void func_8014A59C(s32 a0); +extern void func_8016F14C(void *a0); +extern void func_80154418(void *a0); +extern void func_80154BE4(s32 a0); +extern void func_80165694(s32 arg0); +extern void func_801654A8(s32 a0); +extern void func_8014A680(s32 a0); +extern void func_8014A6A8(s32 a0); +extern void func_8014A71C(s32 a0); +extern void func_80172588(s32 *a0); +extern void func_801473DC(s32 *a0); +extern void func_80015978(s32 a0, s32 *a1); +extern void (*D_8018EE08[])(void *); +extern u8 D_80126BA4; +extern s32 D_80127098; +extern s32 D_80127094; +extern s32 D_80127090; +extern void func_80146534(void); +extern void func_8001D074(s32 a0, s32 a1); +extern void func_80146554(void); +extern void func_80146578(void); +extern void func_8001CFDC(s32, s32); +extern void func_8014659C(void); +extern void func_8001D074(s32, s32); +extern void func_801465C0(void); +extern void func_801465E4(void); +extern void func_801466F0(s32 a0, s32 a1, s32 a2, s32 a3, s32 sp5, s32 sp6, s32 sp7, s32 sp8); +extern s32 D_8011F9D0; +extern s32 func_80146608(s32 a0, s32 a1, s32 a2, s32 a3, s16 arg9, s32 arg10, s32 arg11, s32 arg12, s32 arg13); +extern void func_801466B4(u16 a0, s32 a1, s32 a2, s32 a3, s32 arg5); +extern s32 D_8011F750; +extern s32 D_8011F754; +extern u8 * func_801468C8(s32 arg0, u8 arg1); +extern s32 D_8011D030; +extern s32 func_80146994(s32 a0, s32 a1, s32 a2, s32 a3); +extern s32 func_80146924(s32 a0, s32 a1, s32 a2, s32 a3, s32 arg5); +extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6); +extern s32 func_80146994(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern s32 func_801469C8(int a0, void *a1, int a2, int a3, u16 arg5, int arg6, int arg7, int arg8); +extern s32 func_80146B9C(void *a0); +extern void func_80146AB4(s16 a0, s32 a1, s16 a2, s16 a3, u16 a4, s32 a5, s32 a6); +extern u16 D_8011DA28; +extern s32 func_80146B9C(void * arg0); +extern void func_80146C98(s32 *a0, s16 a1); +extern void func_80146CA0(void *a0); +extern void func_80146CB4(void *a0); +extern void func_80146CC8(s32 a0); +extern void func_80146D30(s32 a0); +extern void func_80146D80(s32 *a0); +extern void func_80146DE8(s32 *a0, s32 a1, s32 a2, s32 a3); +extern void func_80146D90(s32 a0); +extern void func_80146DB8(s32 *a0, s32 *a1); +extern void func_80146DF8(s32 *a0, s32 a1, s32 a2, s32 a3, s32 t0); +extern void func_80146E90(s32 *a0, s32 a1); +extern s32 func_80146E98(s32 a0); +extern void func_80015954(s32 a0, s32 a1); +extern void func_80149374(s32 a0, s32 a1); +extern void func_80146F58(s32 a0, s32 a1); +extern void func_80146EC0(s32 a0, s32 a1, s32 a2, s32 a3); +extern s16 func_8012A68C(void); +extern s16 func_8012A758(void); +extern void func_8004978C(s16 *a0, void *a1); +extern void ApplyMatrixSV(void *a0, void *a1, void *a2); +extern u8 D_80126DB0[]; +extern u16 D_80126DB6; +extern void func_8014704C(s32 *a0); +extern s32 func_80147054(void *a0); +extern void func_80147060(u8 * a0); +extern void func_8014706C(void *arg0); +extern void func_80147078(s32 *a0, s16 a1); +extern void func_80147084(s32 *a0); +extern void func_8014708C(void *arg0); +extern s32 func_801470A0(void *a0); +extern void func_801470AC(s32 *a0); +extern void func_801470B4(s32 arg0); +extern void func_801470C0(s32 a0); +extern void func_80147118(s32 a0); +extern s16 D_80126BB8; +extern s16 D_80126BBA; +extern s16 D_80126BBC; +extern void func_80147264(s32 a0); +extern void func_80147290(void); +extern void func_801472B4(void *a0); +extern s32 func_801472C8(struct S *a0); +extern void *D_8012707C; +extern void func_801472DC(void); +extern void func_801472F0(void *a0); +extern void func_80147364(u16, s32); +extern void func_80147300(u16 arg0); +extern void func_80147324(s32 arg0); +extern void func_801473EC(s32 *a0); +extern void func_80147460(s32 a0); +extern void func_80147514(); +extern void func_80147628(s32 a0); +extern void func_80147478(s32 a0); +extern void func_801474D8(s32 *a0); +extern void func_801474EC(s32 *a0); +extern s32 func_80012C6C(s32 a0, s32 a1, s32 a2); +extern s32 func_800129CC(s32 a0, s32 a1); +extern void func_80147514(s32 arg0); +extern void func_80013F3C(s32 a0); +extern void func_80012558(s32 a0, s32 a1); +extern void func_800126C4(s32 a0, s32 a1); +extern void func_800123F0(s32 a0, s32 a1); +extern void func_80147718(s32 a0); +extern void func_80147788(void *a0, s32 a1); +extern void func_801477A8(void *a0, s32 a1); +extern void func_801477C8(void *a0, s32 a1); +extern void func_801477E8(s32 *a0, s32 a1); +extern void func_80147814(s32 a0, s32 a1); +extern void func_80147928(int a0, int a1); +extern void func_8014799C(int a0, int a1); +extern void func_80147A10(int a0, int a1); +extern void func_80147860(int a0, int a1, int a2, int a3); +extern void func_80147948(s32 a0, s32 a1, s32 a2); +extern void func_801479BC(s32 a0, s32 a1, s32 a2); +extern void func_80147A30(s32 a0, s32 a1, s32 a2); +extern void func_801478B8(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80147948(int a0, int a1, int a2); +extern void func_801479BC(int a0, int a1, int a2); +extern void func_80147A30(int a0, int a1, int a2); +extern void func_80147AD4(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern void func_80147A84(s32 arg0); +extern void func_80147C30(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern void func_80147AAC(s32 arg0); +extern void func_80147CC8(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4); +extern void func_80147B5C(s32 a0, void *a1); +extern void func_80147AD4(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80147D38(s32 a0, s32 a1, s32 a2, s32 a3, void *a4); +extern void func_80147B18(s32 a0); +extern void func_80147B5C(s32 arg0, void *arg1); +extern void func_80147C30(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80147DC0(s32 a0, s32 a1); +extern void func_80147D38(s32 a0, s32 a1, s32 a2, s32 a3, void * a4); +extern void func_800484EC(s32 a0, s32 a1, s32 a2); +extern void func_80147E44(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80147F78(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern void func_80147F50(s32 arg0); +extern void func_80148038(s32 a0, s32 a1); +extern s32 ratan2(s32 a0, s32 a1); +extern s32 csqrt(s32 a0); +extern s32 func_80012A60(s32 a0, s32 a1); +extern void func_80148094(int param_1, short *param_2, int *param_3); +extern void func_801485B8(s32 a0, s32 a1, s32 a2); +extern void func_801484B0(s32 a0, s32 a1); +extern s32 func_80154358(void *a0); +extern void func_801484E8(s32 a0, s32 a1); +extern void func_80148534(s32 a0, s32 a1); +extern void func_8014856C(s32 a0, s32 a1); +extern void func_801485B8(s32 arg0, s32 arg1, s32 arg2); +extern void func_80148634(void *a0); +extern u8 D_800B9A64; +extern s32 func_80014DC0(); +extern s32 func_80014D68(); +extern s32 func_80014D94(); +extern s32 func_80014CF8(); +extern void func_800120DC(); +extern s32 func_800CF8B4(); +extern u16 func_801487F4(s32 *a0); +extern u16 func_80148800(s32 *a0); +extern u8 func_8014880C(s32 *a0); +extern u16 func_80148818(s32 *a0); +extern s32 func_80047D3C(s32 a0); +extern s32 func_80148824(void *arg0); +extern s32 func_801488A8(u8 *a0); +extern s32 func_8014891C(s32 a0); +extern s32 func_80148980(u8 *a0); +extern s32 func_801489E8(s32 a0); +extern s32 func_80148A48(s32 a0); +extern int func_80148AFC(void *a0); +extern void func_80148AAC(u8 *a0); +extern s32 func_80148C18(void); +extern s32 func_80148C20(s32 a0, s16 a1); +extern s32 func_80148C34(s32 a0, s32 a1); +extern s32 func_80148C4C(s32 a0, s32 a1); +extern s32 func_80148C64(s32 a0, s32 a1); +extern s32 func_80148C7C(void); +extern s32 func_80148C84(s32 a0, s32 a1); +extern s32 func_80148C9C(s32 a0, s32 a1); +extern s32 func_80148CB4(s32 a0, s32 a1); +extern s32 func_80148CCC(s32 a0, s32 a1); +extern s32 func_80148CE4(void); +extern s32 func_80148CEC(void); +extern s32 func_80148CF4(s32 a0, s32 a1); +extern s32 func_80148D0C(s32 a0, s32 a1); +extern s32 func_80148D24(void *a0, int a1); +extern s32 func_80148D3C(void); +extern s32 func_80148F60(void); +extern s32 func_80148F68(s32 a0); +extern s32 func_80148F74(s32 a0); +extern s32 func_80148F80(s32 a0); +extern s32 func_80148F8C(s32 a0); +extern s32 func_80148F98(void); +extern s32 func_80148FA0(s32 a0); +extern s32 func_80148FAC(s32 a0); +extern s32 func_80148FB8(s32 a0); +extern s32 func_80148FC4(s32 a0); +extern s32 func_80148FD0(void); +extern s32 func_80148FD8(void); +extern s32 func_80148FE0(s32 a0); +extern s32 func_80148FEC(s32 a0); +extern s32 func_80148FF8(s32 a0); +extern s32 func_80149004(void); +extern void func_8014900C(s32 *a0); +extern void func_80149020(s32 *a0); +extern void func_80149034(s32 *a0); +extern void func_80149048(s32 *a0); +extern void func_8014905C(u8 *a0); +extern void func_801490E0(s32 *a0, s16 a1); +extern void func_801490E8(s32 *a0, s16 a1); +extern void func_801490F0(s32 *a0, s16 a1); +extern void func_80149078(s32 *a0, s32 a1, s32 a2, s32 a3); +extern s32 func_80012B04(s32 a0, s32 a1, s32 a2); +extern void func_801490F8(s32 a0, s32 a1); +extern s32 func_801491C4(s32 a0); +extern s32 func_80149184(s32 a0); +extern void func_80149204(s32 *a0); +extern void func_80149210(s32 a0, s32 a1); +extern s32 func_80149284(s32 *a0, s32 a1); +extern void func_80149350(s32 arg0); +extern void func_80149290(s32 a0); +extern void func_8012F14C(s32 a0, s32 a1, s32 a2); +extern void func_80149374(s32 arg0, s32 arg1); +extern void func_801493D0(s32 param_1, s32 param_2, s32 param_3); +extern void func_8012F038(int param_1, short *param_2, short *param_3); +extern void func_8014942C(s32 arg0); +extern void func_8012EF70(s32 a0, s32 a1); +extern void func_80149544(s32 arg0, s32 arg1, s32 arg2); +extern void func_8012EFB8(s32 a0); +extern void func_80149584(s32 arg0, s32 arg1, s32 arg2); +extern void func_8014964C(s32 param_1, s32 param_2); +extern s32 func_801496D4(void *a0); +extern void func_8015AD08(); +extern void func_80149704(void); +extern void func_8015ACC4(); +extern void func_80149724(void); +extern u8 D_80078EBF; +extern s32 func_80149744(struct S_80149744 *a0); +extern void func_8015F7A0(); +extern void func_80149788(void); +extern void func_801653B8(); +extern void func_80149864(void); +extern s16 currentLocationId; +extern s32 func_8016F1AC(void); +extern s32 func_80149884(void); +extern void func_80160B00(); +extern void func_801498C0(void); +extern s32 func_80149AA8(s32 *a0); +extern s32 func_80149B54(s32 *a0); +extern void func_80146750(void *a0); +extern s32 func_801498E0(s32 *a0); +extern void func_8012E5CC(s32 param_1, u16 param_2, u16 param_3); +extern void func_80147364(u16 a0, s32 a1); +extern s32 func_800CCF28(s32 a0); +extern s32 func_80149954(s32 s0); +extern s32 func_80149A64(s32 *a0); +extern void func_8015DAC4(s32 *a0); +extern void func_8015554C(s32 *a0); +extern void func_80149AD4(s32 *a0); +extern void func_80149B14(s32 *a0); +extern u8 func_8014BEF8(void); +extern s32 func_80149B54(s32 * arg0); +extern void func_8015DE24(s32 *a0); +extern void func_80157510(s32 *a0); +extern void func_80149BAC(s32 *a0); +extern s32 func_80029178(s32 a0); +extern s32 func_80149C08(s32 arg0); +extern void func_801577C8(); +extern void func_80149C94(void); +extern void func_80157D20(void); +extern void func_80149CB4(void); +extern s32 func_80149CD4(s32 a0); +extern u8 func_8014B5B8(s32 *a0); +extern s32 func_80149D10(s32 a0); +extern s32 func_80149E94(s32 a0); +extern s32 func_80149DD8(s32 a0); +extern s32 func_80149D9C(s32 a0); +extern s32 func_80149F2C(s32 a0, s32 a1); +extern s32 func_80149E94(s32 arg0); +extern void func_80149FA8(void); +extern s32 D_8018EED0[]; +extern u8 D_80078E78[]; +extern s32 func_80149FB0(s32 a0); +extern s32 func_80135260(s32 arg0, s32 arg1, s16 *arg2, s16 *arg3); +extern void func_8014A1B0(s32 a0, s32 a1); +extern s32 func_8014A048(s32 param_1); +extern u16 func_80156370(u16 a0); +extern void func_8014C4AC(s32 a0, s32 a1, s32 a2, s16 *a3, s32 a4); +extern void func_8015D4B4(); +extern void func_8014A218(void); +extern s32 func_8014C278(s32 a0, s32 a1, s32 a2); +extern s32 func_8014C2B0(void *a0, void *a1, s32 a2); +extern s32 func_8014A238(s32 arg0); +extern s32 func_8014A2E4(s32 a0); +extern void func_8014A380(s32 a0, s32 a1); +extern s16 D_801152B0; +extern s16 D_801152B4; +extern s32 func_8014A3E0(struct S_8014A3E0 *a0); +extern s32 func_8014A454(s32 a0); +extern s32 func_8014A4B4(void *a0); +extern void func_8015EDD4(); +extern void func_8014A4FC(void); +extern s32 func_8014A674(s32 *a0); +extern s32 func_8014A69C(s32 *a0); +extern s32 func_8014A6C4(s32 a0); +extern void func_8015E184(); +extern void func_8014A830(void); +extern s32 func_80029AF4(void); +extern s32 func_8014A850(s32 param_1); +extern void func_8014AA04(s32 a0); +extern void func_801599A4(void *a0); +extern void func_80159B3C(void *a0); +extern s32 func_80165A20(s32 a0); +extern void func_8014AB7C(); +extern void func_8014AC10(); +extern void func_8014AA28(void); +extern void func_8014AB5C(void); +extern void func_80162CCC(void); +extern void func_8014AB7C(s32 arg0); +extern void func_8014ABF0(void); +extern void func_80016714(void *a0, s32 a1); +extern void func_8014AC10(s32 arg0); +extern void func_8014ACC0(s32 a0, s32 a1); +extern void func_8014AD30(s32 a0, u16 *a1, s32 a2, s32 a3); +extern void func_8014ACE8(void *a0, s32 a1, s32 a2); +extern void func_80146AFC(void *a0); +extern void func_8014ADA8(s32 a0, s32 a1); +extern void func_8014AD7C(s32 a0); +extern s32 D_80078E8C; +extern void func_8014B034(s32 arg0); +extern void func_8014B00C(s32 arg0); +extern void func_8014B084(void); +extern s16 D_80078E90; +extern void func_8014B034(s32 a0); +extern u16 D_80078EAC; +extern u8 D_80078EBA; +extern void func_800D10EC(void); +extern void func_8002AC98(void); +extern s32 func_8014B154(s32 *a0); +extern void func_8014B12C(void); +extern void func_8014B2F8(void); +extern void func_8014B4C4(void); +extern void func_8014B160(s32 a0); +extern s32 func_8016F1C4(void); +extern s16 D_80078E96; +extern s16 D_80078EB8; +extern u16 D_80078EA6; +extern void func_8014B2A8(void); +extern void func_8014B310(void); +extern void func_8014B2D0(void); +extern s32 D_80078E94; +extern s32 D_80078ECC; +extern void func_8014B33C(void); +extern u8 D_80062BF4[]; +extern void func_8014BC80(s32 a0, s32 a1); +extern void func_80019064(void *a0); +extern s32 D_80078E98; +extern void func_80166244(); +extern void func_8014B4D4(void *a0); +extern s16 D_80078E9A; +extern u8 D_80126D1C; +extern s32 D_80126D74; +extern void func_8014B598(s32 a0, s32 a1); +extern void func_8014B5B0(s32 *a0); +extern void func_8014B5C4(s32 *a0, s32 a1, s32 a2); +extern void func_8014B5D8(s32 s1); +extern s32 D_80078E9C; +extern s32 D_80078ED0; +extern void func_8014B6F0(s32 a0, s32 a1); +extern void func_8014B768(s32 a0, s32 a1); +extern void func_8014B944(s32 a0, s32 a1, s32 a2); +extern s32 D_80078EA4; +extern u16 D_80078EB2; +extern s16 D_80078EB4; +extern void func_8014BB0C(void); +extern void func_8014BB24(s32 a0, s32 a1, s32 a2); +extern void func_8014BC0C(s32 a0, s32 a1); +extern void func_8014BC44(s32 a0, s32 a1); +extern u8 D_800B9A17; +extern void func_8014BCC0(s32 a0, s32 a1); +extern u16 D_80078EB6; +extern s32 func_8014BCEC(s32 a0, s32 a1); +extern void func_8014BD24(s32 a0, s32 a1); +extern void func_8014BD60(s32 param_1, s32 param_2); +extern void func_8014BD98(s32 a0, u16 a1); +extern void func_8014BDC8(void); +extern void func_8014BDE0(void); +extern s32 func_8017267C(s32 *a0); +extern s32 func_80013294(void *a0, void *a1); +extern void func_80029ED4(s32 a0); +extern void func_8014BDE8(s32 a0); +extern void func_8014BE78(void); +extern void func_8014BE9C(void); +extern void func_80029124(s32 a0, s32 a1); +extern void func_8014BEC0(void); +extern void func_8014BF18(s32 a0); +extern void func_8014BF48(void); +extern u8 func_8014BF6C(void); +extern void func_8014BF8C(u8 arg0); +extern void func_8014BFB0(void); +extern u8 func_8014BFD4(void); +extern void func_8014BFF4(s32 a0, s32 a1); +extern void func_8014C010(s32 a0, s32 a1); +extern s32 func_8014C050(s32 a0, s32 a1); +extern s32 func_8014C088(s32 a0, s32 a1); +extern s32 func_8014C0C8(s32 a0_unused, s32 a1, s32 a2); +extern s32 func_8014C118(void * a0, s32 a1, s32 a2); +extern s32 func_8014C168(s32 * param_1, s32 param_2); +extern void func_8014C1C8(s32 arg0, s32 arg1, void *arg2); +extern u8 D_8018EF58[]; +extern void func_8014C1A0(s32 arg0, s32 arg1); +extern s32 func_80013328(s32 a0, s32 a1); +extern s32 func_8014C59C(void *a0, void *a1); +extern s32 func_8014C308(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern s32 func_8014C43C(void *a0, s32 a1, s32 a2, s32 a3, s16 a5); +extern s32 func_8014C3A4(void *a0, s32 a1, s32 a2, s32 a3); +extern s32 func_8014C3D0(void *a0, s32 a1, s32 a2, s32 a3); +extern s32 func_8014C43C(void * a0, s32 a1, s32 a2, s32 a3, s16 a4); +extern s32 ratan2(s32 dx, s32 dy); +extern u8 D_8018EF60; +extern s32 func_8014C5FC(s32 a0, s32 a1, void *a2); +extern s16 func_8014C5D0(s32 a0, s32 a1); +extern s32 func_8014C5FC(s32 a0, s32 a1, void * a2); +extern u8 D_80126D17; +extern void func_8014C6AC(void); +extern void func_8014C6C0(void); +extern u8 D_80126D1E; +extern void func_8014C6D0(void); +extern void func_8014C6E0(void); +extern s32 func_8014C860(s32 a0, s32 a1); +extern void func_8014C8C8(s32 a0, s32 *a1); +extern void func_8014C88C(s32 a0); +extern void func_8014C8C8(s32 dst, s32 * src); +extern void func_8014C8F0(s32 arg0); +extern u8 D_801151F0[]; +extern s32 func_8014C918(s32 a0, s32 a1); +extern s32 D_80126B50; +extern void func_8014C968(void); +extern void func_8014C978(void); +extern s32 func_8014C98C(void); +extern void func_80139914(s32 a0); +extern s32 func_8014CA00(s32 a0); +extern u16 func_8014CA70(s32 a0, s32 a1); +extern s32 func_8014CA14(s32 a0, s32 a1); +extern u16 func_8014CAE4(s32 *a0, s32 a1); +extern s32 func_8014CA88(s32 *a0, s32 a1); +extern s32 func_8014CAFC(void); +extern s32 func_8014CB0C(void); +extern s32 func_8014CB1C(void); +extern u8 D_80126D1F; +extern s32 func_8014CB2C(void); +extern s32 func_8014CB58(void); +extern u8 D_80126D1D; +extern void func_8014CB68(void); +extern s32 func_8014CB7C(void); +extern s32 func_8014CB8C(void); +extern short D_80126C9E; +extern void func_8014CB9C(struct Packed8 *a0); +extern s32 D_80126CDC; +extern void func_8014CBD8(void); +extern s16 D_80126CC4; +extern void func_8014CBE8(void); +extern void func_8014CBF8(void *a0); +extern void func_8014D3E0(s32 a0); +extern void func_8014D04C(void); +extern void func_8014CCB4(void); +extern void func_8014CC28(s32 a0); +extern void func_8014CD0C(u8 *a0); +extern s32 func_8014CF04(s32 a0, s32 a1, void *a2); +extern void func_8014CD80(s32 a0, void *a1, void *a2); +extern void func_8014D0A4(s32 a0); +extern s32 func_8014D2A0(s32 a0, void *a1, void *a2); +extern s32 func_8014D12C(s32 a0, void *a1, void *a2); +extern void func_8014D438(s32 a0); +extern void func_8014D3E0(s32 _arg0); +extern void func_8014D610(s32 a0, void *a1, void *a2); +extern s32 func_8014D4C0(s32 a0, void *a1, void *a2); +extern void func_8014D790(s32 a0); +extern void func_8014D738(void); +extern s32 func_8014DD8C(s32 a0, void *a1, void *a2); +extern s32 func_8014D820(s32 a0, u16 *a1, u16 *a2); +extern s32 func_80135888(s32 a0, s32 a1, s32 a2, s32 a3); +extern s32 func_8014DCE0(s32 arg0, s32 arg1, s32 arg2); +extern s32 func_8014DD8C(s32 arg0, void *arg1, void *arg2); +extern void func_8014DF94(s32 arg0); +extern void func_8014DF3C(void); +extern s32 func_8014E284(s32 a0, s16 *a1, s16 *a2); +extern s32 func_8014E048(s32 a0, u16 *a1, u16 *a2); /* u16*: def lhu semantics (T5b reconcile; ptr param type codegen-neutral for the caller) */ +extern s32 func_80135A4C(s32 a0, s32 a1, s32 *a2, s32 a3); +extern s32 func_80133784(s32 a0, void *a1, s32 a2); +extern u8 D_801152A8[]; /* canonical TU type (engine_core) — read via *(u16*) cast */ +extern s16 D_801152AC; +extern s32 func_8014E048(s32 param_1, u16 * param_2, u16 * param_3); +extern void func_8014E48C(s32 a0); +extern void func_8014E434(void); +extern void func_8014E5B4(s32 a0, void *a1, void *a2); +extern s32 func_8014E514(u8 *a0, s32 a1, s32 a2); +extern void func_8014E6F8(struct SubE6F8 *a0); +extern void func_8014E6A0(void); +extern s32 func_8014E83C(s32 a0, s16 *a1, s16 *a2); +extern s32 func_8014E790(s32 a0, s16 *a1, s16 *a2); +extern s32 func_8014E790(s32 arg0, s16 * arg1, s16 * arg2); +extern s32 func_8014E83C(s32 arg0, s16 * arg1, s16 * arg2); +extern void func_8014E934(s32 _arg0); +extern s32 func_8014EA4C(void *a0, void *a1, void *a2, s32 a3); +extern s32 func_8014E98C(void *a0); +extern s32 D_801150D8; +extern s16 D_801152AA; +extern u8 D_80126720[]; +extern s16 D_80126724; +extern s32 func_8014EA4C(void * a0, void * a1, void * a2, s32 _arg3); +extern s32 func_8014ED80(struct SubED80 *a0); +extern int D_801E0DF0; +extern void func_8014ED28(s32 _arg0); +extern s32 func_8014EE14(s32 a0, s16 *a1, s16 *a2); +extern s32 func_8014EE14(s32 arg0, s16 * arg1, s16 * arg2); +extern s32 func_8014F24C(struct SubF24C *a0); +extern void func_8014F1F4(void); +extern s32 func_8014F2E0(s32 a0, s16 *a1, s16 *a2); +extern s32 func_8014F2E0(s32 arg0, s16 * arg1, s16 * arg2); +extern s32 func_8014F4C0(); +extern s32 func_8014F468(void); +extern int func_8014F74C(); +extern int func_8014F6F4(void); +extern u8 D_800D3918[]; +extern u8 D_801152A8[]; +extern s32 D_801152BC; +extern int func_8014F74C(s32 arg0); +extern s32 func_8014FA70(s32 a0); +extern s32 D_801E0DF4; +extern void func_8014FA04(s32 a0); +extern s32 func_8014FBC0(); +extern s32 func_8014FC18(u8 *self); +extern int func_8014FD54(int param_1); +extern void func_8014FCFC(void); +extern void func_80150170(void *a0); +extern s32 func_8014FE60(void *a0); +extern void func_8014FDF4(struct S8014FDF4 *a0); +extern s32 func_8014FE60(void *e); +extern s32 func_80134510(s32 arg); +extern s32 func_80150150(s32 a, s32 b); +extern s32 func_80150460(s32 a, s32 b); +extern void func_801504D8(u16 *a0); +extern s32 func_80150480(s32 _arg0); +extern s32 func_80150528(void *a0, void *a1, void *a2); +extern s32 func_80150528(void *arg0, void *arg1, void *arg2); +extern s32 func_801506A4(s32 a0, s32 a1); +extern s32 func_801505FC(s32 a0); +extern s32 func_801506A4(s32 arg0, s32 arg1); +extern void func_80150820(s32 a0, s32 a1); +extern void func_8015086C(int param_1); +extern s32 func_801508B4(s32 a0); +extern s32 func_8015094C(s32 a0); +extern short func_801508F8(s32 a0); +extern s32 D_8018EF90; +extern s32 D_80126990; +extern s32 D_80126994; +extern u8 D_80126948[]; +extern s32 func_80021174(s32 a0, s32 a1); +extern s32 func_8015094C(s32 param_1); +extern void func_80150B9C(void); +extern s32 func_80151184(s32 a0, s32 a1, s32 a2); +extern s32 func_80150BA4(s32 a0); +extern s32 func_801619D0(void *a0); +extern void func_80150BC8(s32 *a0); +extern s32 func_80150480(s32 a0); +extern u16 D_800AE6DC; +extern void func_80150C48(s32 a0); +extern int func_80151184(int arg, int a1, int a2); +extern int func_80150CA0(int arg); +extern void func_80150EC4(s32 a, s32 b); +extern void func_80150CC4(s32 a); +extern void func_80150CE4(s32 a); +extern void func_80150D04(s32 a); +extern void func_80150D24(s32 a); +extern void func_80150D44(s32 a); +extern void func_80150D64(s32 a); +extern void func_80150D84(s32 a); +extern void func_80150DA4(s32 a); +extern void func_80150DC4(s32 a); +extern void func_80150DE4(s32 a); +extern void func_80150E04(s32 a); +extern void func_80150E24(s32 a); +extern void func_80150E44(s32 a); +extern void func_80150EC4(s32 a0, s32 a1); +extern void func_80150E64(s32 a0); +extern void func_80150E84(s32 a0); +extern void func_80150EA4(s32 a0); +extern u8 D_800AE6C0; +extern s16 D_800AE6C8; +extern s16 D_800AE6CA; +extern s16 D_800AE6CC; +extern s32 D_800AE6C4; +extern s16 D_800AE6CE; +extern u8 D_800AE6BE; +extern u8 D_801201F8[]; +extern void func_80150F78(void); +extern void func_80150F80(s32 a0); +extern int func_80150FB4(int arg); +extern void func_80150FD8(s32 a0); +extern int func_80151014(int arg); +extern void func_80151038(s32 a0); +extern int func_80151070(int arg); +extern int func_80151094(int arg); +extern void func_801510B8(void); +extern void func_801510C0(void); +extern int func_801510C8(int arg); +extern int func_801510EC(int arg); +extern s32 func_8012DB84(void); +extern s32 func_80151110(void); +extern void func_80151130(void); +extern int func_80151138(int arg); +extern void func_8015115C(s32 *a0, s16 a1); +extern s32 func_80151164(s32 a0, s32 a1); +extern s32 func_80151184(s32 arg0, s32 arg1, s32 arg2); +extern void func_801511A8(u8 *a0); +extern void func_801511C4(u8 *a0); +extern int func_80151204(int arg, int a1); +extern int func_801511E0(int arg); +extern int func_80151204(int a0, int a1); +extern void func_80151238(void *a0); +extern void func_8015126C(u16 *p); +extern void func_80151780(s32 a0); +extern void func_801516F0(s32 *a0); +extern void func_8015173C(s32 *a0); +extern s16 D_8011DB1A; +extern s32 D_80127518; +extern s32 D_801151FC; +extern s32 func_801725CC(u8 *a0); +extern s32 func_80029D3C(void); +extern void func_80151878(void); +extern void func_80153B58(s32 *a0); +extern s32 func_80151880(s32 a0); +extern s32 func_801518D8(s32 a0); +extern s32 func_80151944(void *a0); +extern s32 func_80151924(void); +extern void func_8014E934(s32 a0); +extern s32 func_8014F3E8(s32 a0); +extern void func_801519C8(s32 a0); +extern void func_80151980(s32 a0); +extern M2C_UNK D_800D5880; +extern s32 D_800D58AC; +extern void func_80154274(s32 *a0, s32 a1); +extern void func_80154A74(s32 a0, s32 a1); +extern void func_801519C8(s32 arg0); +extern void func_80151C54(s32 a0); +extern void func_801542DC(s32 *a0, s32 a1); +extern void func_8015BDD0(s32 *a0); +extern void func_80165718(s32 a0); +extern u8 D_800D46E4[]; +extern void func_80151AE4(s32 arg0); +extern void (*D_8018F038[])(void); +extern void func_80151D24(void *a0); +extern void func_80151DB0(s32 a0); +extern void func_80151D60(void *a0); +extern s32 func_80172630(u8 *a0); +extern s32 D_80062C14; +extern void func_80151DB0(s32 param_1); +extern void func_80151E78(s32 *a0); +extern void func_80151ECC(struct S80151ECC *a0); +extern void func_80151FB4(s32 a0); +extern void func_80151F38(s32 *a0); +extern void func_801553C0(s32 a0); +extern void func_80153C18(); +extern void (*D_8018F05C[])(void); +extern void func_80152058(void *a0); +extern void func_801520DC(s32 a0); +extern void func_80152094(s32 a0); +extern void func_80147324(s32 a0); +extern u8 D_80062C04[]; +extern M2C_UNK D_8018F04C; +extern void func_801520DC(s32 arg0); +extern void func_801470B4(s32 a0); +extern void func_8015369C(s32 a0); +extern void func_80152194(s32 *a0); +extern s32 func_801536DC(s32 a0); +extern void func_8015220C(s32 a0); +extern s32 func_80153800(s32 a0); +extern void func_801522CC(s32 a0); +extern void func_80152254(s32 *a0); +extern void (*D_8018F070[])(void); +extern void func_80152370(void *a0); +extern void func_801523F4(s32 a0); +extern void func_801523AC(s32 a0); +extern void func_8001382C(s32 a0, void *a1, void *a2); +extern u8 D_8018F07C[]; +extern void func_801523F4(s32 arg0); +extern void func_801525F4(int); +extern s32 func_801535F4(void *arg0); +extern void func_8015BF48(s32 *a0); +extern void func_80152500(int param_1); +extern void func_801525F4(s32 a0); +extern void (*D_8018F08C[])(void); +extern void func_80152698(void *a0); +extern void func_80152714(s32 a0); +extern void func_801526D4(s32 a0); +extern void func_80152790(s32 a0); +extern void (*D_8018F0A4[])(void); +extern void func_8015282C(void *a0); +extern void func_801528B0(s32 a0); +extern void func_80152868(s32 a0); +extern M2C_UNK D_8018F094; +extern void func_801528B0(s32 arg0); +extern void func_8015294C(s32 a0); +extern void func_80152A08(s32 a0); +extern void func_80152AC8(s32 a0); +extern void func_80152A50(s32 *a0); +extern void (*D_8018F0B8[])(void); +extern void func_80152B6C(void *a0); +extern void func_80152BF0(s32 a0); +extern void func_80152BA8(s32 a0); +extern void func_80152C80(s32 *a0); +extern void func_80152C40(s32 *a0); +extern void (*D_8018F0D4[])(void); +extern void func_80152D24(void *a0); +extern void func_80152DA8(s32 a0); +extern void func_80152D60(s32 a0); +extern M2C_UNK D_8018F0C4; +extern void func_80152DA8(s32 arg0); +extern void func_80152E4C(s32 a0); +extern void func_80152EFC(s32 a0); +extern void func_80152FBC(s32 a0); +extern void func_80152F44(s32 *a0); +extern void (*D_8018F0E8[])(void); +extern void func_80153060(void *a0); +extern void func_801530E4(s32 a0); +extern void func_8015309C(s32 a0); +extern void func_80155440(s32 *a0); +extern void func_801530E4(s32 arg0); +extern void func_80153150(struct S80153150 *a0); +extern void func_801531BC(s32 a0); +extern void func_8015327C(s32 a0); +extern void func_80153204(s32 *a0); +extern void (*D_8018F0FC[])(void); +extern void func_80153320(void *a0); +extern void func_801533A4(s32 a0); +extern void func_8015335C(s32 a0); +extern void func_80153410(s32 *a0); +extern void func_80153490(s32 a0); +extern void func_80153550(s32 a0); +extern void func_801534D8(s32 *a0); +extern void (*D_8011DB28)(s32 a0); +extern s32 func_801536DC(s32 param_1); +extern void func_800139C8(s32 a0, void *a1, void *a2); +extern s32 func_80153978(s32 a0, u16 *src); +extern s32 func_80133784(s32 a0, void *src, s32 dst); +extern s32 func_801539F8(s32 a0, void *a1); +extern s32 func_801539F8(s32 a0, void * a1); +extern s32 func_8016DA04(s32 a0); +extern s32 func_80153BD8(s32 a0); +extern s32 func_80153BF0(s32 a0); +extern void func_80153C18(void); +extern u16 D_8011F748; +extern void func_80153C30(void); +extern void func_80153C74(s16 a0, s16 a1); +extern s16 D_8011DB18; +extern void func_80153C44(int a0, int a1, s16 a2); +extern s16 D_8011DB0C; +extern s32 D_80115210; +extern void func_80153C8C(void); +extern void func_80153C9C(void); +extern s32 func_80153CBC(void); +extern s32 D_8018F110; +extern void (*D_8018F138[])(void *a0); +extern void func_80153CCC(S80153CCC *a0); +extern void func_80153D7C(s32 a0); +extern void func_80153D34(s32 a0); +extern u8 D_8018F118; +extern void func_80153D7C(s32 param_1); +extern void func_8015410C(void); +extern void func_80153E00(s32 param_1); +extern void func_80151664(void); +extern void func_80154134(u8 *a0); +extern void func_80154190(u8 *a0, s32 a1); +extern void func_80154150(s32 a0, s32 a1); +extern void func_80154218(u8 *a0, s32 a1, s32 a2); +extern void func_801541D8(u8 *a0, s32 a1, s32 a2); +extern s32 func_801549F8(s32 a0, s32 a1, s32 a2); +extern void func_801542A4(); +extern void func_801542A4(s32 *a0, s32 a1); +extern void func_8015430C(); +extern void func_8015430C(u8 *arg0, s32 arg1, s32 arg2); +extern void func_8015444C(void *a0, s32 *a1, s32 *a2, s32 *a3); +extern s32 func_80154358(void * arg0); +extern void func_80154AB4(s32 a0, s32 a1); +extern void func_80154B20(s32 a0, s32 a1, s32 a2); +extern void func_80154AE0(s32 a0, s32 a1, s32 a2); +extern void func_80154B7C(u8 *a0, s32 a1); +extern void func_80154B4C(u8 *a0, s32 a1); +extern void func_80154BC8(void *a0, s32 a1, s32 a2); +extern void func_80154B98(void *a0, s32 a1, s32 a2); +extern u8 D_800D8D10[]; +extern s16 D_80078E9E; +extern void func_801550FC(s32 a0); +extern void func_80154ED8(s32 a0, s32 a1); +extern void func_80154F9C(s32 a0); +extern void func_800183E0(s32 a0); +extern void func_801550FC(s32 arg0); +extern void func_8001D150(s32, s32); +extern void func_8001D130(int, int); +extern void func_80155150(int param_1); +extern s32 D_800DE2A4[]; +extern void func_801552F4(s32 a0); +extern void func_80155344(s32 a0); +extern s32 func_80155394(s32 *a0); +extern void func_801553A8(s32 *a0); +extern s32 func_80029178(s32); +extern int (*D_8018F184[])(void); +extern s32 func_80155458(s32 param_1); +extern s32 func_801659DC(u8 *a0); +extern s32 func_801554B8(void *arg0); +extern void func_801555F4(void *a0); +extern void func_80155518(s32 *a0); +extern void func_80155580(void *a0); +extern void (*D_8018F188[])(void); +extern s32 func_80161104(void); +extern void func_801555F4(void *); +extern void func_801555BC(void *a0); +extern int func_80155A44(int param_1); +extern int func_80161208(); +extern u8 D_800D4DA8[]; +extern void func_80155B20(s32 *a0); +extern s32 D_800D4DB4; +extern void func_80155B9C(s32 a0); +extern u8 D_800D4DD4[]; +extern void func_80155C0C(s32 *a0); +extern void func_8014ED28(s32 a0); +extern int func_80155FF8(int arg, int a1); +extern s32 D_800D4DF4; +extern void func_80155C64(s32 a0); +extern void func_8015E880(s32 *a0); +extern void func_80155D70(s32 param_1); +extern void func_80155E30(void *a0); +extern s32 func_80161208(); +extern void func_80155EA4(void *arg0); +extern void func_80155F58(void); +extern s32 func_80155F80(); +extern s32 func_80155F60(void); +extern s32 func_80155F80(s32 a0); +extern int func_80155FB0(int arg, int a1); +extern int func_80155FD4(int arg, int a1); +extern int func_80156044(int arg, int a1); +extern s32 func_80029B4C(s32 a0, s32 a1); +extern s32 func_80029BC8(s32 a0, s32 a1); +extern s32 func_80029C44(s32 a0, s32 a1); +extern s32 func_8015640C(s32 a0, s32 a1); +extern s32 rand(void); +extern u32 func_8015616C(s32 param_1, u16 param_2); +extern u16 func_80156370(u16 param_1); +extern s32 func_801564B0(s32 a0); +extern s32 func_8002A1B4(void); +extern s32 func_8002A400(void); +extern s32 func_8002A670(void); +extern s32 func_8002A8E0(void); +extern s32 D_801151E0[]; +extern s32 func_801565C0(void); +extern void func_80156A14(s32 *a0); +extern void func_80156648(s32 *a0); +extern u8 D_8011DAD8[]; +extern s32 func_8014C568(s16 *a0, s16 *a1); +extern void func_801567BC(s32 a0); +extern u8 D_80126730[]; +extern void func_80156848(s32 param_1, s32 param_2); +extern unsigned char D_8011520C[]; +extern unsigned short D_8018F5EC[]; +extern void func_80156A1C(s32 param_1, s32 param_2); +extern s32 D_801150E0[]; +extern void func_80156A88(s32 a0, s32 a1); +extern void func_80156B74(s32 param_1, u32 param_2, u8 *param_3); +extern void func_80156ECC(int param_1, int param_2, int param_3, int param_4, int param_5); +extern void func_80156FA8(s16 *param_1, s16 *param_2, s16 *param_3); +extern void func_80157158(s32 a0, u16 a1, u16 a2, s32 a3, s32 a4, s32 a5, s32 a6, s32 a7, s32 a8, s32 a9, u16 a10, s32 a11, s32 a12); +extern s32 func_80135004(s32 a0, void *a1, s32 a2); +extern u32 func_801571C4(s32 a0, u16 a1, u16 a2, s32 a3, s32 a4, s32 a5, s32 a6, s32 a7, s32 a8, s32 a9, u16 a10, s32 a11, s32 a12); +extern void func_801575E4(void *a0); +extern void func_801574DC(s32 *a0); +extern void func_80157544(void *a0); +extern void (*D_8018F5FC[])(void); +extern void func_8014CC28(s32 a0); /* defined */ +extern s32 func_8014F3E8(s32 a0); /* declared */ +extern void func_8015BDD0(s32 *a0); /* defined */ +extern void func_801575E4(void *a0); /* defined */ +extern void func_80157580(s32 arg0); +extern u8 D_800D4F14[]; +extern void func_801576A8(void *arg0); +extern s32 func_8015773C(u8 *a0); +extern s32 func_8015771C(u8 *a0); +extern s32 func_8015773C(u8 * arg0); +extern int D_801E0E28; +extern void func_801578C0(s32 a0); +extern void func_80157788(int param_1); +extern void func_801577C8(s32 arg0); +extern void (*D_8018F624[])(void); +extern void func_80157808(void *param_1); +extern void func_80157880(s32 a0); +extern s32 func_801725A4(u8 *a0); +extern u8 D_800D5128; +extern u8 D_8018F604; +extern void func_801578C0(s32 param_1); +extern void func_80147A84(int); +extern void func_80148038(int, int); +extern void func_80147460(int); +extern void func_80146D90(int); +extern void func_80161450(void *a0); +extern void func_80157A8C(int); +extern void func_80154A74(int, int); +extern unsigned char D_800D5178; +extern unsigned char D_8018F614; +extern void func_8015795C(int param_1); +extern void func_80161D20(s32 a0, s32 a1); +extern void func_80157A8C(s32 a0); +extern void func_8016706C(s32 a0); +extern u8 D_800D51AC[]; +extern void func_80157AC8(s32 param_1); +extern void func_80157B74(int param_1); +extern void func_8016158C(void *a0); +extern void func_8015BE04(s32 *a0); +extern void func_80157BC8(s32 a0); +extern void func_80157CCC(s32 a0); +extern void func_80157DC4(void *a0); +extern void func_80157FC4(void *a0); +extern void func_80157D74(u16 *a0); +extern void (*D_8018F664[])(void); +extern void func_80157E38(void *); +extern void func_80157E00(void *a0); +extern void func_80157E38(void * a0); +extern s32 func_80157F64(s32 *a0); +extern s32 func_80156600(void *a0); +extern void func_80157EA4(void *a0); +extern void (*D_8018F66C[])(void); +extern void func_80158038(void *); +extern void func_80158000(void *a0); +extern s32 D_800D51E0; +extern s32 D_8018F638; +extern void func_80158038(void * param); +extern u8 D_800D524C[]; +extern void func_80161418(void *a0); +extern void func_801580B4(s32 a0); +extern void func_801581AC(s32 a0); +extern void (*D_8018F678[])(void); +extern void func_8015824C(void *a0); +extern void func_801582C0(void *); +extern void func_80158288(void *a0); +extern u8 D_800D52A8[]; +extern void func_801585A4(s32 *a0); +extern void func_801582C0(void *a0); +extern s32 func_801585AC(s32 *a0); +extern u8 D_800D52E8[]; +extern void func_80158344(s32 *a0); +extern s32 func_801615C4(void *a0, s32 a1); +extern u8 D_8018F648; +extern u8 D_800D533C; +extern void func_80158434(s32 param_1); +extern void func_80158548(s32 param_1); +extern void func_801585EC(u8 *a0); +extern void func_80158794(void); +extern s32 D_801E0E30; +extern s32 D_801E0E3C; +extern s32 D_801E0E40; +extern void func_80158880(s32 *param); +extern void func_8015879C(s32 param_1); +extern void func_80158814(void *arg0); +extern void (*D_8018F6B4[])(s32 *); +extern void func_80158AE4(void *a0); +extern void func_80158AB4(void *a0); +extern void func_8016F264(void); +extern void func_80165840(void); +extern void func_801658DC(void); +extern void func_80165A78(s32); +extern void func_80158AE4(void * a0); +extern M2C_UNK D_800D58D8; +extern void func_80158BB0(void *arg0); +extern s32 func_80159404(s32 a0, s32 a1); +extern void func_80158C40(s32 *a0); +extern void func_80158CD8(s32 *a0); +extern s32 func_80159434(s32 a0, s32 a1); +extern void func_80158D60(s32 a0); +extern M2C_UNK D_800D5904; +extern void func_80158E24(s32 *a0); +extern s32 D_8018F688[]; +extern int rand(void); +extern s32 func_8013767C(s32 a0); +extern void func_80158F00(int param_1); +extern u8 D_80110C3C[]; +extern s32 func_801399F0(s32); +extern void func_80139914(s32); +extern s32 func_80159464(void); +extern void func_801594E8(s32, s32); +extern void func_80158FA4(s32 param_1); +extern s32 func_801399F0(s32 a0); +extern u8 D_80110C94[]; +extern u8 D_80110CD4[]; +extern void func_80159070(void *a0); +extern s32 func_80029A94(s32); +extern void func_80175454(void); +extern void func_800298BC(void *); +extern void func_8002992C(s32); +extern void func_800CF804(void); +extern void func_800CF818(void); +extern u8 D_80110D0C[]; +extern void func_80159120(s32 a0); +extern void func_801592CC(s32 *a0); +extern u8 D_800AE6BD; +extern s32 D_801E0E38; +extern void func_8015934C(void *arg0); +extern void func_801593E4(A801593E4 *a0); +extern void (*D_8018F904[])(void); +extern void func_80159698(void *a0); +extern s32 func_801596D4(void *a0); +extern void func_80174B6C(void); +extern void func_80129248(s16 a0); +extern void func_8013C938(void); +extern void func_8013CB20(void); +extern void func_8013C98C(void); +extern void func_8002850C(s32, s32, s32); +extern void func_80028620(s32, void *); +extern s16 D_800B9AAC[]; +extern s16 D_800B9B00; +extern u16 D_801270C0; +extern u32 D_800AFAE8[]; +extern char D_8018F724[]; +extern s32 func_801596F0(s32 param_1); +extern s32 func_80159874(void); +extern void func_800167B8(s32 a0); +extern s32 func_8015987C(s32 a0); +extern int func_800167F0(int arg); +extern int func_801598BC(void); +extern void func_80159968(void *a0); +extern void func_801598E0(u8 *a0); +extern void (*D_8018F9A8[])(void); +extern void func_80159A20(void *a0); +extern void func_801599E0(void *a0); +extern void func_80159A18(void); +extern void func_80159BE4(s32); +extern void func_80159B08(s32 *a0); +extern void func_80159B70(void *a0); +extern void func_80159B3C(void * a0); +extern void (*D_8018FAFC[])(void); +extern void func_80159BAC(s32 a0); +extern s32 func_80172590(u8 *a0); +extern unsigned char D_8018F918; +extern void func_80159BE4(s32 arg0); +extern void func_8015A1C8(s32 a0); +extern void func_8015A2D8(s32); +extern void func_8015A1FC(s32 *a0); +extern void func_8015A264(void *a0); +extern void func_8015A230(s32 *a0); +extern void (*D_8018FB04[])(void); +extern void func_8015A2A0(s32 a0); +extern int D_8018F928; +extern s32 func_80172608(u8 *a0); +extern void func_8015A2D8(s32 param_1); +extern u8 D_800D48DC; +extern s32 func_8015AB7C(s32 a0); +extern s32 D_8011F9C4; +extern s32 func_8015ABD4(s32 a0, s32 a1, s32 a2); +extern s32 func_80161CD0(s32 a0, s32 a1); +extern M2C_UNK D_8018F948; +extern void func_8015AC48(s32 arg0); +extern void func_8015AC90(s32 a0); +extern void func_8015ADB0(s32 a0); +extern void func_8015ACC4(s32 *arg0); +extern void func_8015AD3C(void *a0); +extern void func_8015AD08(void *arg0); +extern void (*D_8018FB0C[])(void); +extern void func_8015ADB0(s32); +extern void func_8015AD78(s32 a0); +extern void func_8015ADB0(s32 arg0); +extern s32 D_800D4A9C; +extern int func_8015B6F4(int param_1); +extern u8 D_800D4F8C[]; +extern s32 func_8015B7B4(s32 a0); +extern u8 D_800D4BE0[]; +extern s32 func_8014A51C(int param_1); +extern s32 func_8015B858(u8 *a0); +extern s32 D_800D4B48; +extern void func_8015B8F8(s32 *a0); +extern void func_8015BD8C(s32 *a0); +extern s32 func_8015BE94(); +extern void func_8015BE38(struct Obj *a0); +extern s32 func_8015BE74(void); +extern void func_80161124(void *a0); +extern s32 func_8015BE94(s32 *a0); +extern s32 func_8015AE2C(); +extern s32 func_8015BEC4(void); +extern s32 func_8015B950(s32 arg0); +extern s32 func_8015BEE4(void); +extern void func_8015BF04(s32 *a0); +extern void func_8015C0C4(s32 a0); +extern void func_8015BFF4(void *a0); +extern void func_8015BF7C(s32 *a0); +extern void func_8015C030(s32 *a0, s32 a1); +extern void func_8015BFB0(s32 *a0, s32 a1); +extern void (*D_8018FB34[])(void); +extern void func_8015C0C4(s32); +extern void func_8015C08C(s32 a0); +extern s32 func_8015C128(s32 param_1); +extern void func_8015C6A4(void); +extern void func_8015C788(s32 a0); +extern void func_8015C6AC(s32 *a0); +extern void func_8015C714(void *a0); +extern void func_8015C6E0(s32 *a0); +extern void (*D_8018FB40[])(void); +extern void func_8015C788(s32); +extern void func_8015C750(s32 a0); +extern void func_8015CB94(s32 a0); +extern void func_8015CBCC(void); +extern void func_8015CBD4(void); +extern void func_8015CBDC(void); +extern void func_8015CBE4(void); +extern void func_8015CBEC(void); +extern void func_8015CBF4(void); +extern void func_8015CBFC(void); +extern void func_8015CC04(void); +extern void func_8015CC0C(s32 *param_1); +extern void func_8015CC74(s32 *a0); +extern void func_8015CC40(s32 *a0); +extern s32 func_8015CCD0(); +extern s32 func_8015CCB0(void); +extern s32 func_801725E0(u8 *a0); +extern s32 func_8015CCD0(s32 param_1); +extern s32 func_8015CD20(s32 arg0); +extern void func_8015CF24(s32 a0); +extern void func_8015D01C(); +extern void func_8015CF58(s32 *param_1); +extern void func_8015CFC0(s32 *a0); +extern void func_8015CF8C(s32 *a0); +extern void func_8015CFFC(void); +extern void func_8015D01C(int param_1); +extern void (*D_8018F9B4[])(void *); +extern s32 func_801725F4(u8 *a0); +extern void func_8015D104(void *arg0); +extern s32 D_8018FBE4; +extern void func_8015D380(s32 a0); +extern unsigned char D_8018ECC8[]; +extern void func_8015D414(int param_1); +extern void func_8015D57C(s32); +extern void func_8015D480(s32 *a0); +extern s32 func_8015D4E8(s16 *a0); +extern void func_8015D4B4(s16 *a0); +extern void func_8015D524(s32 arg0); +extern void func_8015D544(s32 a0); +extern void func_801746DC(void); +extern void func_8015D57C(s32 arg0); +extern s32 func_80161B18(void *a0); +extern s32 func_80161B84(void *a0); +extern void func_80154150(int, int); +extern void func_80149374(int, int); +extern unsigned char D_8018FBF8[]; +extern void func_8015D5E8(int param_1); +extern int func_8015E0D4(int); +extern void func_8015DA5C(s32 a0); +extern void func_8015DB6C(s32 a0); +extern void func_8015DA90(s32 *a0); +extern void func_8015DAF8(s32 *a0); +extern void func_8015DB6C(s32); +extern void func_8015DB34(s32 a0); +extern void func_8015DCB8(s32 a0); +extern void func_8014BD60(s32 a0, s32 a1); +extern int func_8015DD74(int); +extern void func_8015DBD4(void *arg0); +extern int func_8015DC84(int a0); +extern s8 D_8018FC34[]; +extern void func_8015DCB8(s32 param_1); +extern int func_8015DD74(int arg0); +extern void func_8015DECC(s32 a0); +extern void func_8015DDF0(s32 *a0); +extern void func_8015DE58(s32 *a0); +extern void func_8015DECC(s32); +extern void func_8015DE94(s32 a0); +extern void func_8015E018(s32 a0); +extern void func_8015DF34(void *arg0); +extern int func_8015DFE4(int a0); +extern void func_8015E018(s32 param_1); +extern int func_8015E0D4(int a0); +extern void func_8015E22C(s32 a0); +extern void func_8015E150(s32 *a0); +extern s32 func_8015E1B8(s32 a0); +extern void func_8015E184(s32 *arg0); +extern void func_8015E22C(s32); +extern void func_8015E1F4(s32 a0); +extern u8 D_800D4FF4[]; +extern u8 D_800D5098[]; +extern u8 D_800D5060[]; +extern s32 func_8014A850(s32 a0); +extern void func_8015E40C(s32 a0); +extern void func_8015E588(void); +extern void func_8015E4B0(s32 a0); +extern void func_8015E288(s32 a0); +extern u16 D_8018FC7C; +extern u16 D_8018FC7E; +extern u16 D_8018FC80; +extern s32 D_8018FC84; +extern void func_80013E94(void *a0, void *a1); +extern void func_8015E4B0(s32 param_1); +extern void func_8013C9C4(void *a0); +extern s32 D_8018FC8C; +extern void func_8015E5B0(u8 *self); +extern void func_8015E714(s32 *a0); +extern void func_8015E95C(s32); +extern void func_8015E84C(s32 *a0); +extern void func_8015E8E8(s32 *a0); +extern void func_8015E9B8(s32 *a0); +extern void func_8015E8B4(s32 *a0); +extern void func_8015E924(s32 a0); +extern void func_8015E95C(s32 a0); +extern s16 D_801152A0; +extern void func_80160818(s32 *a0); +extern void func_8015ED6C(s32 *a0); +extern void func_8015EE7C(s32); +extern void func_8015EDA0(s32 *a0); +extern s32 func_8015EE08(s32 a0); +extern void func_8015EDD4(s32 *arg0); +extern void func_8015EE44(s32 a0); +extern int D_800D4C48; +extern int D_8018F998; +extern void func_8015EE7C(s32 param_1); +extern void func_8015EEE0(void *arg0); +extern void func_8015EF9C(void); +extern void func_8015F080(s32); +extern void func_8015EFA4(s32 *a0); +extern void func_8015F00C(s32 *a0); +extern void func_8015EFD8(s32 *a0); +extern void func_8015F048(s32 a0); +extern void func_8015F080(s32 a0); +extern s32 D_80062BE8; +extern void func_801466F0(s32, s32, s32, s32, s32, s32, s32, s32); +extern s32 func_80161208(void); +extern void func_8015F118(void *a0); +extern void func_8015F260(s32 *a0); +extern void func_8015F380(); +extern void func_8015F2BC(s32 *a0); +extern void func_8015F324(s32 *a0); +extern void func_8015F2F0(s32 *a0); +extern void func_8015F360(void); +extern s32 func_801725B8(u8 *a0); +extern void func_8015F380(void* arg0); +extern void func_8015F738(s32 *a0); +extern void func_8015F848(s32 *a0); +extern void func_8015F76C(s32 *a0); +extern s32 func_8015F7D4(s32 a0); +extern void func_8015F7A0(s32 *arg0); +extern void func_8015F810(s32 *a0); +extern void func_80147078(s32 *, s16); +extern void func_80159B70(void *); +extern void func_8015F89C(void *arg0); +extern void func_8015F948(s32 *param_1); +extern void func_8015F9A4(void *arg0); +extern void func_8015FA24(s32 arg0); +extern void func_8015FBE0(s32 *a0); +extern void func_8015FA44(s32 *a0); +extern void func_8015FAAC(s32 *a0); +extern void func_8015FA78(s32 *a0); +extern s32 func_801612B8(void *a0, s32 a1); +extern void func_8016007C(s32 a0); +extern void func_8015FAE8(void *arg0); +extern void func_8015FCC8(void *param_1); +extern unsigned int D_8018FD10[]; +extern void func_8015FD74(int param_1); +extern s32 func_80028DE0(void); +extern u8 func_80165700(s32 a0, s32 a1); +extern void func_8015FDCC(s32 a0); +extern u8 D_80078EC2; +extern u8 func_801656E8(s32 a0, s32 a1); +extern void func_80165670(s32 a0, s32 a1); +extern void func_8016004C(s32 a0); +extern void func_8015FF20(void *param_1); +extern void func_801601AC(s32 *a0); +extern void func_801600D0(s32 *a0); +extern void func_80160138(s32 *a0); +extern void func_80160104(s32 *a0); +extern void func_80160174(s32 *a0); +extern void func_801601E4(s32 *a0); +extern void func_80160244(s32 *a0); +extern void func_8016032C(void); +extern void func_80160410(s32 *a0); +extern void func_80160334(s32 *a0); +extern void func_8016039C(s32 *a0); +extern void func_80160368(s32 *a0); +extern void func_801603D8(s32 *a0); +extern u8 D_80062BD0; +extern void func_80160410(s32 * a0); +extern void func_801607B8(s32 *a0); +extern void func_801608C0(s32 *a0); +extern void func_801607E4(s32 *a0); +extern void func_8016084C(s32 *a0); +extern void func_80160888(s32 *a0); +extern void func_80160A28(s32 a0); +extern void func_80160A74(s32 *a0); +extern void func_80160BB4(s32 *a0); +extern void func_80160ACC(s32 *a0); +extern s32 func_80160B34(s32 a0); +extern void func_80160B00(s32 *arg0); +extern void func_80160B70(s32 a0); +extern void func_80160C28(void *arg0); +extern void func_80160CB4(s32 *a0); +extern void func_80160D10(void *arg0); +extern void func_80160DEC(u8 *a0); +extern void func_80160F00(); +extern void func_80160E3C(s32 *a0); +extern void func_80160EA4(); +extern void func_80160E70(s32 *a0); +extern void (*D_8018FDC0[])(void); +extern void func_80160EA4(void *a0); +extern void func_80160EE0(void); +extern void func_80160F00(void* arg0); +extern void func_800D0F4C(s32 a0); +extern u8 D_80110EC0; +extern void func_80160F70(s32 a0); +extern void func_80160FE0(s32 *a0); +extern void func_80161034(void *a0); +extern void func_80161094(s32 a0); +extern void func_801610FC(void); +extern void func_801483E8(unsigned char *self); +extern s32 func_80161A60(s32 a0); +extern void func_8016130C(void *a0, s32 a1); +extern void func_80161240(void *a0); +extern void func_80161374(void *a0, s32 a1); +extern void func_80161278(void *a0); +extern s32 func_801612B8(void * a0, s32 a1); +extern void func_8016163C(void *a0, s32 a1); +extern void func_80161774(void *a0, s32 a1); +extern s32 func_8016197C(s32 a0, s32 a1); +extern s32 func_80161488(void *a0); +extern void func_80161888(void *a0, s32 a1); +extern void func_801614E4(void *a0); +extern void func_8016191C(void *a0, s32 a1); +extern void func_8016151C(void *a0); +extern void func_80161554(void *a0); +extern s32 func_801615C4(void * arg0, s32 arg1); +extern s32 func_801619A4(s32 *a0); +extern s32 func_80161A00(s32 a0); +extern s32 func_80161A30(s32 a0); +extern int func_801497A8(s32 *a0); +extern int func_80161BE0(void *param_1); +extern u16 D_8018FDF0[]; +extern void func_80161C98(int param_1, u32 param_2); +extern void func_80161E08(s32); +extern s32 func_80162438(s32); +extern s32 D_800AE6A8; +extern void func_800D1734(void *); +extern s32 D_8018FE54; +extern void func_80161D88(void); +extern void func_80161E08(s32 param_1); +extern int func_800291DC(int); +extern int func_800D0E30(void *a0); +extern int func_801620C4(void); +extern s32 func_800D0D7C(s32, s32); +extern int D_801E0E48[]; +extern void func_8016216C(void); +extern u8 D_80078EB0; +extern u8 D_80078EB1; +extern s32 func_801621CC(s32 arg0); +extern void func_801622C4(void); +extern void (*D_8018FE78[])(void); +extern void func_80162330(void *a0); +extern void func_8014706C(void *a0); +extern s32 func_8016236C(u8 *a0); +extern void func_800D0C48(s32 a0); +extern s32 func_801623B8(s32 *a0); +extern s32 func_800167F0(s32 a0); +extern s32 func_80162414(void); +extern s32 func_80162438(s32 _unused0); +extern int func_801626B8(void); +extern void func_80162714(void); +extern int D_801E0EA0[]; +extern void func_80162760(void); +extern void func_801627C0(void); +extern void (*D_8018FEC0[])(void); +extern void func_80162834(void *a0); +extern void func_8001CB6C(u8 *a0, s32 a1, s32 a2, s32 a3); +extern void func_80162968(s32 a0); +extern s32 func_80162ACC(u8 *a0); +extern u8 D_800B5CB8; +extern s32 D_8018FEB0; +extern s32 D_800B5CBC; +extern u8 D_800B5CDF; +extern s32 D_800B5CEC; +extern void func_80162870(s32 param_1); +extern void func_801628F4(s32 *a0); +extern void func_80162968(s32 param_1); +extern void func_80162AC0(s32 *a0, s8 a1); +extern s32 func_80162AE0(u8 *a0); +extern void func_80162AF4(void); +extern void func_80162CC4(void); +extern s32 D_80126D40; +extern void func_80162B1C(void); +extern void func_80162D28(s32 *a0); +extern void func_80162D88(s32 *a0); +extern void func_80162DE8(s32 *a0); +extern void func_80162E48(s32 *a0); +extern void func_80162EA8(s32 *a0); +extern void func_80162F60(s32 arg0, s32 arg1); +extern void func_80162F80(s32 arg0, s32 arg1); +extern void func_80162FA0(s32 arg0, s32 arg1); +extern void func_80162F08(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80162FC0(s32 *a0); +extern void func_80162FF4(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_801630C4(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80163194(s32 a0, s32 a1, s32 a2, s32 a3, s32 arg4); +extern void func_8016325C(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80163234(s32 a0); +extern s32 D_80115100; +extern s32 func_801632E0(void); +extern s32 D_80115200; +extern s32 func_801632F0(void); +extern u16 D_80126B18[]; +extern void func_80163328(void); +extern s32 func_801633A8(void); +extern s32 func_80163408(s32 param_1, s32 param_2, s32 param_3, s32 param_4); +extern void func_80163534(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, u16 * a5); +extern void func_8016345C(s32 a0, u16 a1, s32 a2, u16 a3, s32 a4); +extern char D_801E0598[8]; +extern void *memcpy(void *dst, const void *src, unsigned int n); +extern void func_801634D8(s32 param_1, u16 param_2, u16 param_3, s32 param_4, u16 param_5); +extern void func_80157158(); +extern void func_80163664(s32 a0, u16 a1, u16 a2, s32 a3, s32 a4, s32 a5, s32 a6, s32 a7, s32 a8, s32 a9, u16 a10, s32 a11, s32 a12); +extern void func_801636D0(s32 a0, s32 a1); +extern s32 func_8016380C(struct S8016380C *a0, s32 a1); +extern void *memcpy(void *dst, void *src, s32 n); +extern s32 func_801638A0(u8 *a0, s32 a1); +extern s32 func_80163950(s32 a0); +extern void (*D_8018FEC8[])(void); +extern void func_80163A58(void *a0); +extern void func_80163A94(s32 param_1); +extern void func_80163C2C(s32 param_1); +extern void func_80163EC8(s32 param_1); +extern void func_80164270(s32 *a0); +extern void func_80164418(s32 s0); +extern void func_80163764(s32 a0); +extern void func_801642AC(s32 a0); +extern void func_8016432C(s32 a0); +extern void func_80164410(void); +extern s32 func_80012DBC(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80164530(s32 arg0); +extern void (*D_8018FF1C[])(void); +extern void func_80164744(s32 param_1); +extern void func_8001C810(s32 a0, s32 a1); +extern void func_80164A74(s32 *a0); +extern void func_80164930(s32 a); +extern u16 D_800DF2E0; +extern s32 D_8018FEE4; +extern s16 D_8018FF18; +extern s16 D_8018FF16; +extern s16 D_8018FF14; +extern void func_801647A4(int param_1); +extern void func_80164ACC(); +extern void func_80164864(void *a0); +extern void func_80164930(s32 param_1); +extern s32 func_8014C308(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80164ACC(s32 a0); +extern void (*D_8018FF28[])(void); +extern void func_80164BA0(void *a0); +extern void func_8001CD50(s32 a0, s32 a1); +extern void func_800233CC(void *, unsigned short); +extern void func_80164DD0(s32 a0); +extern void func_80164DB0(void); +extern u8 D_801E0F00; +extern u8 D_801E0F01; +extern u8 D_801E0F02; +extern u8 D_801E0F03; +extern u8 D_801E0F04; +extern u8 D_801E0F05; +extern u8 D_801E0F06; +extern u8 D_801E0F07; +extern void func_80164BDC(s32 param_1); +extern void func_80164E40(void); +extern void func_80164CD4(u8 *a0); +extern void func_80164D4C(void *arg0); +extern void (*D_8018FF38[])(void); +extern void func_80164EA4(void *a0); +extern void func_80165124(void *a0); +extern void func_80164EE0(int param_1); +extern s32 func_80165140(s32 a0); +extern void func_801651B8(void *a0); +extern void func_80164F44(void *arg0); +extern void func_80165024(void *a0); +extern void func_80165064(s32 *a0); +extern void func_801650C4(s32 *a0); +extern s32 func_80165140(s32 param_1); +extern s32 func_80165240(s32 a0, s32 a1, s32 a2); +extern s32 D_801E0F40; +extern void func_801651B8(void * param_1); +extern u8 D_80126CF8; +extern void func_8016533C(void); +extern void func_801653F4(s32 a0); +extern void func_80165580(s32 a0); +extern void func_80165374(s32 a0); +extern void func_80165580(s32 _arg0); +extern void func_801653B8(s32 *a0); +extern s32 func_80165624(s32 a0); +extern u8 D_80078EC5; +extern void (*D_8018FF7C[])(void); +extern u8 func_80165658(s32 a0, s32 a1); +extern void func_800CAE0C(s32 a0); +extern void func_801654A8(s32 arg0); +extern void func_80165B28(void *a0); +extern void func_801655E4(s32 a0); +extern u8 D_8018FFF8[]; +extern s32 D_80190018[]; +extern u8 D_80190094[]; +extern u8 func_801656D0(s32 a0, s32 a1); +extern u8 D_801900B4[]; +extern u8 D_801900D4[]; +extern void func_800CAF6C(s32 *a0); +extern void func_80165770(void); +extern void func_801657D8(void); +extern u8 D_80078EC3; +extern void func_801657A0(void); +extern s32 D_80078EA0; +extern s32 D_80078EA8; +extern u8 D_80078EBB; +extern s32 D_80078ED4; +extern s32 D_80078ED8; +extern s32 D_80078EDC; +extern u8 D_80078EE0; +extern void func_80165874(void); +extern s8 D_80078EC4; +extern void func_801658EC(void); +extern s32 func_80165900(void); +extern s32 func_80165910(void); +extern s32 D_8012672C; +extern s32 D_8012811C; +extern s32 D_80126B08; +extern void func_80165938(void); +extern void func_80165958(void); +extern s32 func_80165978(void); +extern void func_80165988(void); +extern s32 func_801659A8(void); +extern void func_801659B8(void); +extern s32 func_801659CC(void); +extern void func_80165A18(void); +extern s32 func_80165A50(s32 _arg0); +extern void func_80165AC8(void); +extern void func_80165A78(s32 arg0); +extern void (*D_80190170[])(void); +extern void func_80165B08(void); +extern void func_80165B10(void); +extern void func_80165B18(void); +extern void func_80165B20(void); +extern void (*D_801901EC[])(void); +extern void func_80165BB4(u8 *a0); +extern void func_80165B6C(u8 *a0); +extern void func_80165C58(s32 arg0); +extern void func_80165BFC(void *a0); +extern void func_80165C78(void); +extern M2C_UNK D_801E05A8; +extern void func_80165E2C(u16 *arg0); +extern s32 func_80165FA4(s32 a0, s32 a1, s32 a2); +extern s32 func_80167DBC(s32 a0, s32 a1, s32 a2); +extern s32 func_80167AE0(s32 a0, s32 a1, s32 a2); +extern void func_80165E90(void); +extern void func_80020F34(s32 a0, s32 a1); +extern s32 func_80165FA4(s32 arg0, s32 arg1, s32 arg2); +extern void (*D_801901F8[])(void); +extern void func_80166018(void *a0); +extern void func_80166054(s32 arg0); +extern void func_801661CC(s32 param_1); +extern void func_80166244(void* arg0); +extern void func_8016629C(void *a0); +extern void func_801662F4(void *a0); +extern void func_8016634C(void *a0); +extern void func_801663A4(void *a0); +extern void (*D_80190200[])(void); +extern void func_801663FC(void *a0); +extern s32 func_800D21C4(s32 a0, void *a1, s32 a2); +extern void func_800D1FC8(s32 a0, s32 a1); +extern void func_80128EA8(s32 a0, s32 a1, s32 a2); +extern void func_801665B4(); +extern void func_80146C3C(); +extern void func_80166438(u8 *a0); +extern s32 func_80128ED8(s32 param_1, s32 *param_2); +extern void func_800D22E4(s32 a0); +extern void func_801665B4(s32 *a0); +extern void (*D_801902C8[])(void); +extern void func_80166618(void *a0); +extern void (*D_801902D8[])(void); +extern void func_80166654(void *a0); +extern s32 func_80166690(s32 param_1, s32 param_2); +extern s32 func_80166994(); +extern s32 func_80166F58(s32 param_1, s32 param_2, s32 param_3, s32 param_4); +extern s32 func_80167540(s32 arg0); +extern void (*D_801902E8[])(void); +extern void func_801678B4(void *a0); +extern void RotMatrixYXZ(void *a0, void *a1); +extern void func_80048EAC(void *a0, void *a1); +extern s32 func_801670E4(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80146C3C(void); +extern void func_801678F0(s32 a0); +extern void (*D_801902F4[])(void); +extern void func_80167A9C(void *a0); +extern void func_80167AD8(void); +extern s32 func_80167AE0(s32 param_1, s32 param_2, s32 param_3); +extern void func_80168070(s32 a0, s16 *a1, s16 *a2, void *a3); +extern u8 D_80190254[]; +extern u8 D_80190268[]; +extern s32 func_80167DBC(s32 arg0, s32 arg1, s32 arg2); +extern void func_800D20C0(void *a0, void *a1, s32 a2); +extern void func_80017E68(void *a0, void *a1); +extern void func_800D23D0(void *a0); +extern void ApplyTransposeMatrixLV(void *a0, void *a1, void *a2); +extern s32 D_801269A4; +extern s32 D_801269A8; +extern s32 D_801269AC; +extern void func_80168070(s32 param_1, s16 *param_2, s16 *param_3, void *param_4); +extern s32 func_80166994(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_8016829C(s32 a0); +extern s32 func_80166690(s32 a0, s32 a1); +extern void func_80168328(s32 arg0); +extern void func_801683D8(s32 a0); +extern void func_801684B4(s32 a0); +extern void func_80168540(s32 a0); +extern void func_801685EC(s32 a0); +extern void func_80168640(s32 a0); +extern s32 RotMatrixX(s32 a0, void *a1); +extern void func_80168664(void *arg0); +extern void (*D_8019030C[])(void); +extern void func_80168744(void *a0); +extern void func_80168BDC(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_801687CC(s32 a0); +extern void func_80168780(s32 a0); +extern void func_80168828(void); +extern void func_801687CC(s32 param_1); +extern void func_80168828(); +extern void (*D_80190314[])(void); +extern void func_801689D8(void *a0); +extern void func_80168A14(s32 *a0); +extern void func_80168A88(void); +extern void (*D_8019031C[])(void); +extern void func_80168AA8(void *a0); +extern void func_80168AE4(s32 a0); +extern void func_800D2318(s32 *p); +extern void func_80168BDC(s32 param_1, s32 param_2, s32 param_3, s32 param_4); +extern void (*D_80190324[])(void); +extern void func_80168D58(void *a0); +extern void func_80168D94(int a0); +extern void func_80168F40(); +extern void func_80168EC4(s32 a0); +extern void func_80168F40(void *arg0); +extern void (*D_8019032C[])(void); +extern void func_8016901C(void *a0); +extern void func_80169058(s32 a0); +extern s32 func_80169228(void); +extern void func_801691B8(void *a0); +extern void (*D_80190334[])(void); +extern void func_801693CC(void *a0); +extern void func_80169584(s32 param_1); +extern void func_80169408(s32 a0); +extern void func_8016951C(int param_1); +extern s32 func_80017758(void *a0, void *a1); +extern s32 func_80017DC4(void *a0, void *a1); +extern void func_801696D8(s32 a0, s32 a1); +extern void (*D_8019033C[])(void); +extern void func_80169830(void *a0); +extern void func_8016986C(s32 a0); +extern s32 func_80169A4C(s32 a0, s32 a1); +extern void func_801699D0(void *arg0); +extern void (*D_801903F0[])(void); +extern void func_80169B80(void *a0); +extern void func_80169E44(s32 a0); +extern void (*D_801903F8[])(void); +extern void func_80169F00(void *a0); +extern char D_801903A8[]; +extern char D_80190368[]; +extern void func_80169F3C(int param_1); +extern void func_80169FE0(s32 a0); +extern void (*D_80190430[])(void); +extern void func_8016A020(void *a0); +extern void func_8016A05C(void *a0); +extern void func_8016A290(s32 a, void *b, void *c); +extern void func_8016A08C(s32 param_1); +extern void func_8016A1CC(int param_1); +extern void func_8016A290(s32 param_1, void *param_2, void *param_3); +extern void (*D_8019043C[])(void); +extern void func_8016A700(void *a0); +extern s32 func_8016A73C(s32 arg0); +extern s32 func_8016A8FC(s32 a0); +extern void func_8016A890(s32 arg0); +extern void func_8016AA50(s32 param_1, s32 param_2); +extern void (*D_80190484[])(void); +extern void func_8016AB30(void *a0); +extern void func_8016B234(s32 param_1); +extern void func_8016AFB0(s32 a0); +extern void func_8016B114(void *arg0); +extern s32 func_8016B448(s32, s32); +extern s32 func_8016BA48(s32 a0); +extern void func_8016B3F4(s32 a0); +extern s32 func_8016B428(s32 a0); +extern void func_8016B984(void *a0); +extern s32 func_8016B448(s32 arg0, s32 arg1); +extern void (*D_80190500[])(void); +extern void func_8016B4BC(void *a0); +extern int func_8016B9F8(int); +extern int func_8016B834(int, int); +extern void func_8016B91C(int); +extern int D_801E1260; +extern void func_8016B4F8(int param_1); +extern s32 func_8016B9F8(s32 param_1); +extern void func_8016B6BC(s32, s32, s32, s32); +extern void func_8016B91C(s32); +extern s16 D_801904F4[]; +extern void func_8016B5C0(s32 param_1); +extern void func_8001CD9C(int, void *); +extern int *D_80190538[]; +extern unsigned short D_80190540[]; +extern unsigned short D_80190548[]; +extern unsigned char D_801E1268[]; +extern int func_8016B834(int param_1, int param_2); +extern void func_8016B964(SrcB964 *a0, DstB964 *a1); +extern void func_8016B91C(s32 arg0); +extern s32 D_801E1260; +extern s32 func_8016BA68(s32, s32); +extern void func_8016BADC(void *a0, s32 a1, s32 a2); +extern void (*D_80190550[])(void); +extern void func_8016BBA4(void *a0); +extern s32 func_8016BBE0(s32 param_1); +extern void func_8016BFA8(s32 a0, s32 a1, s32 a2, s32 a3); +extern M2C_UNK D_801E139C; +extern M2C_UNK D_801E13A0; +extern void func_8016BCC0(void *arg0); +extern s32 func_8016BD78(s32 param_1); +extern s32 func_8016BEA0(s32 param_1); +extern void func_8016BF34(void *a0); +extern void func_8016BFD0(s32 a0, s32 a1, s32 a2, s32 a3, void *a4); +extern s32 D_801E1328; +extern void (*D_80190580[])(void); +extern void func_8016C14C(void *a0); +extern s32 func_8016C374(s32 a0, s32 a1, s32 a2, s32 a3); +extern u8 D_801E13A4[]; +extern u8 D_801E13AC[]; +extern u8 D_801E135C[]; +extern void func_8016C2C4(s32 param); +extern s32 func_8016C49C(s32 param_1_arg); +extern s32 VectorNormalSS(void *a0, void *a1); +extern void func_8016C74C(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4); +extern short func_8016CF04(s32 a0, s32 a1); +extern void func_8016C83C(s32 a0); +extern void (*D_80190588[])(void); +extern void func_8016CB84(void *a0); +extern short func_8016CF04(s32 param_1, s32 param_2); +extern void (*D_801905A4[])(void); +extern void func_8016D19C(void *a0); +extern void (*D_801905AC[])(void); +extern void func_8016D428(void *a0); +extern void func_8016D464(u8 *a0); +extern void func_8016D4DC(s32 a0); +extern void func_8016D5EC(s32 *a0); +extern short func_8016CBC0(void); +extern void func_8016D64C(int param_1); +extern void func_8016D778(s32 a0); +extern void func_800D20C0(); +extern void func_8016D848(s32 *a0); +extern void func_8016D984(s32 *a0); +extern void func_8016DBD8(u8 *a0); +extern void (*D_80190614[])(int); +extern void func_8016DA30(int param_1); +extern s32 func_8001CC3C(s32 a0, s32 a1, s32 a2, s32 a3); +extern u8 D_801905B8; +extern u8 D_801905C4; +extern void func_8016DA7C(s32 param_1); +extern void func_8016DB34(s32 param_1); +extern void (*D_80190648[])(void); +extern void func_8016DEA4(void *a0); +extern void func_8016DEE0(s32 a0); +extern void (*D_80190650[])(void); +extern void func_8016DF20(void *a0); +extern void func_8016E3CC(s32 a0); +extern void func_8016E1CC(s32 a0); +extern void func_8016E26C(s32 *a0); +extern void func_8016E2E8(void *a0); +extern void func_8016E460(void *a0, void *a1); +extern void func_8016E358(void *a0); +extern void func_8016E460(void *arg0, void *arg1); +extern void (*D_801906A4[])(void); +extern void func_8016E5B8(void *a0); +extern void func_8016E5F4(s32 arg0); +extern void func_8016E778(); +extern void func_8016E688(void *a0); +extern void func_8016E6E4(s32 a0); +extern void func_8016E728(u8 *a0); +extern void func_8016E7C8(int param_1, short *p1, unsigned int *p2); +extern void func_8016E778(int param_1); +extern void func_8016E7C8(int param_1, short *param_2, unsigned int *param_3); +extern s32 D_80115218; +extern void func_8016E8F0(void); +extern void func_8016E918(short param_1, short param_2); +extern s32 func_8016E95C(); +extern u16 D_801906D8[]; +extern s32 func_8016EC0C(s32 a0, s32 a1); +extern void func_8016EAC0(Wave *param_1); +extern u8 D_801906C8[]; +extern void func_8016EB3C(s32 p); +extern void func_8016EBA8(u8 *param_1); +extern void func_8016ED6C(void); +extern s32 D_80126D70; +extern void func_8016EDEC(s32 a0, s32 a1, s32 a2); +extern void func_8016ED8C(s32 a0, s32 a1, s32 a2); +extern void func_8016EE40(s32 a0, s32 a1, s32 a2); +extern void func_8016EDBC(s32 a0, s32 a1, s32 a2); +extern void func_8016EE94(); +extern void func_8016EDEC(s32 _arg0, s32 _arg1, s32 _arg2); +extern void func_8016EF78(s32 a0); +extern void func_8016EE40(s32 _arg0, s32 _arg1, s32 _arg2); +extern void func_801726D0(void *a0); +extern s32 D_80126D50; +extern s32 D_80126D54; +extern u8 D_80126D6C; +extern u8 D_80126D6D; +extern u8 D_80126D6E; +extern s32 D_80126D5C; +extern s32 D_80126D60; +extern s16 D_80126D64; +extern s16 D_80126D66; +extern s16 D_80126D68; +extern s16 D_80126D6A; +extern u8 D_80126D1A; +extern s32 D_80127058; +extern s32 D_8012705C; +extern s32 D_80127060; +extern s32 D_80127064; +extern s32 D_80127068; +extern s32 D_8012706C; +extern s32 D_80127070; +extern s32 D_80127074; +extern s16 D_80126D20; +extern void func_8016EE94(s32 a0, s32 a1); +extern s32 func_8016EFC8(s32); +extern s32 func_8016EFA8(s32 a0); +extern void func_8016F094(s32 *a0); +extern s32 func_8016F0AC(); +extern s32 D_801906F4; +extern void func_8016F250(void); +extern void func_8016F288(void); +extern void func_8016F2A8(void); +extern void func_8016F2C8(void); +extern void func_8016F2EC(void); +extern void func_8016F30C(void); +extern void func_8016F330(void); +extern void func_8016F350(void); +extern void func_8016F374(void); +extern void func_8016F388(void); +extern void func_8016F398(void); +extern s32 func_8016F44C(s32 a0); +extern void func_8016F470(s32 a0); +extern s32 func_8016F410(s32 a0); +extern void func_80175414(s32 _arg0); +extern s32 func_8016F4C4(s32); +extern s32 func_8016F494(s32 a0); +extern void func_8016F0E4(void); +extern s32 func_8016F4C4(s32 param_1); +extern void func_8016F4F4(void); +extern void func_801719A4(int a0, int a1); +extern void func_800D1724(s32 a0); +extern void func_80171928(void *a0); +extern void *D_8011F738; +extern void func_8016F4FC(void *a0); +extern void func_8014708C(void *a0); +extern void func_8016F540(void *a0); +extern void func_8016F578(s32 *a0); +extern void func_8016F5B0(void *a0); +extern void func_80147060(u8 *a0); +extern void func_8016F5E0(u8 *a0); +extern void func_8016F610(void *a0); +extern void func_8016F648(void *a0); +extern void func_8016F680(void *a0); +extern void func_8016F6B0(void *a0); +extern void (*D_8019076C[])(void); +extern void func_8016F6E0(void *a0); +extern s32 func_80171990(u8 *a0); +extern void func_8016F764(void *a0); +extern void func_8016F71C(u8 *a0); +extern void (*D_80190774[])(void); +extern void func_8016F798(void *a0); +extern void func_8016F804(void *a0); +extern void func_8016F7D4(u8 *a0); +extern void func_80171928(void *); +extern void (*D_8019077C[])(void); +extern void func_8016F834(void *a0); +extern void func_8016F8AC(u8 *a0); +extern void func_8016F870(u8 *a0); +extern void func_80172358(u8 *a0, u8 *a1); +extern void (*D_80190784[])(void); +extern void func_8016F8E4(void *a0); +extern void func_8016F95C(void *a0); +extern void func_8016F920(u8 *a0); +extern s32 func_80171CC4(void *a0, void *a1); +extern s32 func_80171D1C(void *a0, void *a1, s32 a2); +extern u16 D_8011F73E; +extern void (*D_8019078C[])(void); +extern void func_8016F9C4(void *a0); +extern void func_80171B44(s32 *a0); +extern void func_8016FA44(s32 a0); +extern void func_8016FA00(s32 a0); +extern s32 func_80171C64(s32 a0, s32 a1); +extern void (*D_80190794[])(void); +extern void func_8016FA84(void *a0); +extern void func_8016FB10(void *a0); +extern void func_8016FAC0(u8 *a0); +extern void func_8016FB50(void *a0); +extern void (*D_801907A0[])(void); +extern void func_8016FB7C(void *a0); +extern void func_8016FC24(); +extern void func_8016FBB8(s32 a0); +extern s32 func_80171B4C(s32 a0, s32 a1); +extern void func_8016FC24(s32 a0); +extern void func_8016FC64(void *a0); +extern void (*D_801907AC[])(void); +extern void func_8016FC90(void *a0); +extern void func_8016FD08(u8 *a0); +extern void func_8016FCCC(u8 *a0); +extern s32 func_80172658(s32 *a0); +extern void func_8016FD08(u8 *s0); +extern void func_8016FD7C(s32 *a0); +extern void (*D_801907B8[])(void); +extern void func_8016FDB4(void *a0); +extern void func_8016FE2C(u8 *a0); +extern void func_8016FDF0(u8 *a0); +extern void func_8016FE2C(u8 * a0); +extern s32 func_8016FE78(s32 *a0); +extern s32 func_80172664(s32 *a0); +extern void func_8016FED0(s32 *a0); +extern void (*D_801907C8[])(void); +extern void func_8016FF30(void *a0); +extern void func_8016FFA8(u8 *a0); +extern void func_8016FF6C(u8 *a0); +extern void (*D_801907D8[])(void); +extern void func_8016FFDC(void *a0); +extern void func_80170068(u8 *a0); +extern void func_80170018(u8 *a0); +extern void func_801700B8(u8 *a0); +extern void func_80170100(u8 *a0); +extern void (*D_801907E0[])(void); +extern void func_80170150(void *a0); +extern void func_801701C8(u8 *a0); +extern void func_8017018C(u8 *a0); +extern void func_801701C8(u8 * a0); +extern void (*D_801907E8[])(void); +extern void func_80170240(void *a0); +extern void func_801702B8(s32 a0); +extern void func_8017027C(u8 *a0); +extern s16 func_80171AB0(s32 a0, void *a1); +extern void (*D_801907F0[])(void); +extern void func_801702FC(void *a0); +extern void func_80170374(u8 *a0); +extern void func_80170338(u8 *a0); +extern s32 func_8014C168(s32 *a0, s32 a1); +extern void func_80170374(u8 * a0); +extern void (*D_801907F8[])(void); +extern void func_801703E0(void *a0); +extern void func_8017044C(u8 *a0); +extern void func_8017041C(u8 *a0); +extern void func_8017044C(u8 * a0); +extern void (*D_80190800[])(void); +extern void func_801704B0(void *a0); +extern void func_8017051C(void *a0); +extern void func_801704EC(u8 *a0); +extern void (*D_80190808[])(void); +extern void func_80170548(void *a0); +extern void func_801705C0(u8 *a0); +extern void func_80170584(u8 *a0); +extern void func_801705C0(u8 * a0); +extern void (*D_80190810[])(void); +extern void func_801705F8(void *a0); +extern void func_80170670(void *a0); +extern void func_80170634(u8 *a0); +extern void func_8012A568(void (*a0)(void)); +extern void (*D_80190818[])(void); +extern void func_801706AC(void *a0); +extern void func_80170718(void *a0); +extern void func_801706E8(u8 *a0); +extern void func_80129FF4(void); +extern void (*D_80190820[])(void); +extern void func_80170748(void *a0); +extern void func_801707D4(void *a0); +extern void func_80170784(u8 *a0); +extern s32 func_80174ED4(void); +extern void (*D_80190828[])(void); +extern void func_80170810(void *a0); +extern void func_801708B0(void *a0); +extern u8 D_800D5DA8; +extern void func_8017084C(s32 a0); +extern u8 D_800D5A34[]; +extern void func_80170AD8(void *a0); +extern void func_80171904(s32 a0); +extern void func_80170B48(int a0); +extern void func_80170928(void); +extern u8 D_800D59EC[]; +extern void func_80170970(void); +extern u8 D_800D599C[]; +extern void func_801709B8(void); +extern u8 D_800D5934[]; +extern void func_80170A00(void); +extern void func_80170A48(void); +extern u8 D_800D5DC0[]; +extern void func_80170A90(void); +extern void (*D_80190830[])(void); +extern void func_80170B14(int a0); +extern void func_80170B90(u8 *a0); +extern void (*D_80190838[])(void); +extern void func_80170BD8(void *a0); +extern void func_80170C44(u8 *a0); +extern void func_80170C14(u8 *a0); +extern void (*D_80190840[])(void); +extern void func_80170C74(void *a0); +extern s32 func_8017197C(u8 *a0); +extern void func_80170CF0(void *a0); +extern void func_80170CB0(u8 *a0); +extern void (*D_80190848[])(void); +extern void func_80170D68(void *a0); +extern void func_80170DE0(u8 *a0); +extern void func_80170DA4(u8 *a0); +extern s32 D_8011F73C; +extern s32 D_8011F740; +extern void func_801718AC(void *a0); +extern void func_80170DE0(u8 * _arg0); +extern void (*D_80190850[])(void); +extern void func_80170E34(void *a0); +extern void func_80170EAC(u8 *a0); +extern void func_80170E70(u8 *a0); +extern int func_800D0F8C(int a0); +extern void func_80170EAC(u8 * _arg0); +extern void (*D_80190858[])(void); +extern void func_80170EFC(void *a0); +extern void func_80170F74(void *a0); +extern void func_80170F38(u8 *a0); +extern void (*D_80190860[])(void); +extern void func_80170FB0(void *a0); +extern void func_80171028(void *a0); +extern void func_80170FEC(u8 *a0); +extern void (*D_80190868[])(void); +extern void func_80171064(void *a0); +extern void func_801710DC(u8 *a0); +extern void func_801710A0(u8 *a0); +extern u16 D_8011F73A; +extern void func_801710DC(u8 * arg0); +extern void (*D_80190870[])(void); +extern void func_80171120(void *a0); +extern void func_8017118C(u8 *a0); +extern void func_8017115C(u8 *a0); +extern void func_80142454(s32 a0); +extern void func_8017118C(u8 * a0); +extern void (*D_80190878[])(void); +extern void func_801711C0(void *a0); +extern void func_80171238(void); +extern void func_801711FC(u8 *param_1); +extern void (*D_80190880[])(void); +extern void func_80171260(void *a0); +extern s32 func_80012F74(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80171384(void *a0); +extern void (*D_80190888[])(void); +extern void func_801714E4(void *a0); +extern void func_8017162C(void *a0); +extern void func_80171520(s32 a0); +extern s32 func_801716AC(s32 a0, void *a1, s32 *a2); +extern s32 func_80012FC8(s32 a0, s32 a1, s32 a2, s32 a3); +extern u8 D_800A5E94; +extern u8 D_800A5E95; +extern u8 D_800A5E96; +extern s32 func_801716AC(s32 a0, void * a1, s32 * a2); +extern int func_800D0FE0(int a0); +extern void func_801717A0(void *a0); +extern void func_8013E588(void *a0); +extern void func_801717F4(void *a0); +extern void func_80171824(void *a0); +extern void func_80171854(void *a0); +extern void func_80171884(void); +extern void func_80171A1C(u8 *a0); +extern void func_80171928(void * a0); +extern void func_8017196C(s32 *a0, s8 a1); +extern void func_80171A04(s32 *a0); +extern void func_80171A10(s32 *a0); +extern void func_80171A34(s32 *a0, s8 a1); +extern s32 func_80171A44(u8 *a0); +extern s32 func_80171A58(u8 *a0); +extern s32 func_80171A6C(u8 *a0); +extern void func_80171A80(s32 *a0, s32 a1); +extern s32 func_80171A88(s32 a0); +extern s16 func_80171AB0(s32 param_1, void * _arg1); +extern void func_80171B10(void *a0); +extern void func_80171EC8(s32 a0); +extern s32 func_80171C64(s32 param_1, s32 param_2); +extern s32 func_80171D78(s32 a0, s32 a1); +extern int func_8017250C(short *a0, short *a1); +extern s32 func_80171CC4(void * a0, void * a1); +extern s32 func_80171FFC(short *a0, short *a1, s32 a2); +extern s32 func_80171D1C(void * a0, void * a1, s32 a2); +extern s32 func_8017248C(s32 a0, s32 a1); +extern s32 func_80171E08(s32 arg0, s32 arg1, s32 arg2); +extern s32 func_80047948(s32 a0); +extern s32 func_8004787C(s32 a0); +extern void func_80172170(s32 a0, s32 a1); +extern s32 func_8017209C(void *arg0, void *arg1, s32 arg2, s32 arg3); +extern void func_801722CC(s32 *a0); +extern void func_80172304(s32 *a0); +extern void func_80172310(u8 *a0); +extern void func_801723C4(s32 param_1, s32 param_2); +extern void func_80161C24(s32, s32); +extern void func_80172414(s32 a0); +extern s32 func_801724EC(s32 a0); +extern s32 func_8017248C(s32 arg0, s32 arg1); +extern s32 func_80013450(s32); +extern s32 func_80172560(u8 *a0, u8 *a1); +extern s32 func_8017261C(u8 *a0); +extern s32 func_80172644(u8 *a0); +extern s32 func_80172670(s32 *a0); +extern s32 func_80172688(s32 *a0); +extern s32 func_80172694(s32 *a0); +extern s32 func_801726A0(s32 *a0); +extern s32 func_801726AC(s32 *a0); +extern s32 func_801726B8(s32 *a0); +extern s32 func_801726C4(s32 *a0); +extern s32 func_80172760(s32 a0); +extern s32 func_80174650(s32); +extern void (*D_80127088)(void); +extern s32 D_801270BC; +extern s16 D_80126B0C; +extern void func_801726D0(void * _arg0); +extern void func_80172710(void); +extern void func_80174684(void *); +extern void func_80172738(void); +extern s16 D_80126B30; +extern s32 func_801727D0(void *a0); +extern void func_80172780(void *a0); +extern void func_80172844(u8 *a0); +extern void func_8017280C(u8 *a0); +extern void func_8017288C(void); +extern s32 func_801728E4(void *a0); +extern void func_80172894(void *a0); +extern void func_80172958(u8 *a0); +extern void func_80172920(u8 *a0); +extern s16 D_80126B36; +extern void func_80172958(u8 * a0); +extern void func_801729A8(void); +extern s32 func_801729F0(void *a0); +extern s16 D_80126B34; +extern s16 D_80126B32; +extern void func_801729B0(s32 a0); +extern void func_80172A8C(void *a0); +extern void func_80172A2C(int param_1); +extern void func_80172ACC(u8 *a0); +extern void func_80172B0C(void); +extern s32 func_80172B44(void *a0); +extern void func_80172B14(s16 a0); +extern s32 D_801150F8; +extern void func_80172BC8(void *a0); +extern void func_80172B80(u8 *a0); +extern void func_80172C48(void); +extern void (*D_801908CC[])(void); +extern void func_80172CA0(void *a0); +extern void func_80172D14(u8 *a0); +extern void func_80172CDC(u8 *a0); +extern void func_80172D14(u8 * a0); +extern void func_80172D60(void); +extern s32 D_80127508; +extern s32 func_80172DAC(void *a0); +extern void func_80172D68(s32 a0); +extern void func_80172E20(u8 *a0); +extern void func_80172DE8(u8 *a0); +extern void func_80172E20(u8 * a0); +extern void func_80172E8C(void); +extern void func_8017303C(void *); +extern void func_80172E94(void); +extern void func_80172ED4(void); +extern void func_80172EFC(void); +extern void func_80172F24(void); +extern u8 D_800D47F4[]; +extern void func_80172F4C(void); +extern void func_80172F9C(void); +extern u8 D_800D5C6C[]; +extern void func_80172FEC(void); +extern s32 func_80173078(void *a0); +extern void func_8017303C(void * a0); +extern void func_801730FC(struct S801730FC *a0); +extern void func_801730B4(s32 a0); +extern void func_8017316C(void); +extern s32 func_8017319C(void *a0); +extern void func_80173174(void); +extern u8 D_800D5AA0[]; +extern void func_80173220(void *a0); +extern void func_801731D8(s32 *a0); +extern M2C_UNK D_80190890; +extern void func_80173220(void * arg0); +extern void func_80173294(void); +extern void func_801732C4(); +extern void func_8017329C(void); +extern void func_801732C4(s32 *a0); +extern void func_8017331C(); +extern void func_801732F4(void); +extern void func_8017331C(s32 *a0); +extern void func_80173374(); +extern void func_8017334C(void); +extern void func_80173374(s32 *a0); +extern void func_801733A4(void); +extern void func_801733CC(s32 a0); +extern void func_801734BC(s32 a0, s32 a1); +extern s16 D_80126B3E; +extern void func_80173460(s32 a0, s32 a1); +extern void func_801734BC(s32 arg0, s32 _unused1); +extern void (*D_801908FC[])(void); +extern void func_80173544(void *a0); +extern void func_801735B8(u8 *a0); +extern void func_80173580(u8 *a0); +extern s16 D_80126B40; +extern void func_801735EC(void *a0); +extern void func_80173648(u8 *a0); +extern void func_801736A8(void); +extern s32 func_8014C118(void *a0, s32 a1, s32 a2); +extern s32 func_801736FC(void *a0); +extern void func_801736B0(s32 a0, s32 a1); +extern void func_80173770(u8 *a0); +extern void func_80173738(u8 *a0); +extern void func_801723C4(s32 a0, s32 a1); +extern void func_801737B0(void); +extern s32 func_801737E8(void *a0); +extern void func_801737B8(s16 a0); +extern void func_8017385C(u8 *a0); +extern void func_80173824(u8 *a0); +extern void func_801738D4(void); +extern s32 func_8017390C(void *a0); +extern void func_801738DC(s16 a0); +extern void func_80173980(u8 *a0); +extern void func_80173948(u8 *a0); +extern void func_801739D8(u8 *a0); +extern void func_80173A20(void); +extern s32 D_8012750C; +extern void func_80173A60(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4); +extern void func_80173A28(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5); +extern void (*D_80190938[])(void); +extern void func_80173B4C(void *a0); +extern void func_80173BC0(u8 *a0); +extern void func_80173B88(u8 *a0); +extern void func_80173C64(u8 *a0); +extern void func_80173E1C(s32 a0); +extern s16 D_80126938; +extern s16 D_80126B3A; +extern void func_800D128C(s32, s32); +extern void func_80174158(s32 a0); +extern void func_8002A088(s32); +extern void func_8002A2D4(s32); +extern void func_8002A544(s32); +extern void func_8002A7B4(s32); +extern s32 func_80174188(s32 a0); +extern void func_801741A8(s32 a0); +extern s32 func_800D0EC4(void); +extern void func_800D0F0C(s32, s32); +extern void func_80145EE8(s32); +extern void func_80173EF8(void *param_1); +extern s32 func_8014BCEC(s32, s32); +extern void func_801741A8(s32 _arg0); +extern s16 D_80126B3C; +extern s16 D_8011F9C8; +extern void func_801741EC(u8 *a0); +extern void func_80174274(void); +extern s32 func_801742A4(void *a0); +extern void func_8017427C(void); +extern void func_80174318(u8 *a0); +extern void func_801742E0(u8 *a0); +extern void func_80174354(void); +extern s32 func_80174384(void *a0); +extern void func_8017435C(void); +extern void func_801743F0(u8 *a0); +extern void func_801743C0(u8 *a0); +extern void func_801743F0(u8 * a0); +extern void func_80174430(void); +extern s32 func_80174474(void *a0); +extern void func_80174438(s32 a0); +extern void func_801744E0(u8 *a0); +extern void func_801744B0(u8 *a0); +extern void func_80174524(void); +extern void func_80174554(); +extern void func_8017452C(void); +extern void func_80174554(s32 arg0); +extern void func_801745AC(); +extern void func_80174584(void); +extern void func_801745AC(s32 *a0); +extern void func_80174604(void); +extern void func_801745DC(void); +extern void func_80174630(void); +extern s32 func_80174650(s32 _arg0); +extern void func_80174674(void); +extern void func_801746A4(void); +extern s32 func_800CF8CC(void); +extern void func_80174714(void); +extern s32 func_80174754(void); +extern s16 func_80174764(void); +extern s16 func_80174774(void); +extern s32 func_801747CC(void *a0); +extern void func_80174784(void); +extern s32 func_801747AC(s32 a0); +extern s32 func_80174808(u8 *a0); +extern void func_8017481C(void); +extern s32 func_80174888(void *a0); +extern void func_80174824(void); +extern void func_8017484C(s32 a0); +extern void func_801748C4(s32 a0); +extern void func_801748E4(void); +extern void func_8012A018(s32 a, s32 b); +extern s32 func_8017496C(void *a0); +extern s32 D_80126954; +extern s32 D_80126950; +extern s32 D_8012695C; +extern s16 D_80126968; +extern s16 D_8012696A; +extern s16 D_8012696C; +extern s16 D_80126976; +extern s16 D_80126978; +extern s16 D_8012697A; +extern void func_801748EC(void); +extern s32 func_801749C8(); +extern s32 func_801749A8(s32 a0); +extern void func_80174BBC(void *a0); +extern void func_8012A0E0(void); +extern void func_80174BF4(void *a0); +extern void (*D_80190990[])(); +extern void func_80174BF4(void * arg0); +extern s32 func_80174CB0(s32, s32); +extern s32 func_80174C60(s32 a0); +extern void func_80174C80(s32 a0); +extern s32 D_8012697C; +extern u16 D_80126980; +extern s32 func_80174F28(void *a0); +extern void func_80174E9C(s32 a0); +extern void func_80174EF0(s32 a0, s16 a1); +extern s32 func_80175014(u8 *a0, u8 *a1, s32 a2); +extern void func_80174F64(u8 *a0); +extern void func_80174FBC(u8 *a0); +extern s32 func_8017509C(u8 *a0, s32 a1, u8 *a2, u8 *a3); +extern void func_80175184(s32 *a0); +extern void func_80175114(s32 *a0); +extern void func_80175184(); +extern void func_80175150(s32 *a0); +extern void (*D_801909A0[])(void*); +extern s32 func_80175268(s32); +extern void func_80175184(s32* arg0); +extern s32 func_80175218(void *a0); +extern void func_801751D8(void *a0); +extern void (*D_801909A8[])(s32); +extern s32 func_80175218(void * param_1); +extern void func_801752BC(s32 *a0); +extern u8 D_8011F7A8; +extern u8 D_8011F7A9; +extern u8 D_8011F7AD; +extern u8 D_8011F7AE; +extern void func_80175414(s32 _arg0); +extern void func_80175494(void); +extern void (*D_80190B10[])(); +extern s32 func_801758FC(void); +extern s32 func_80175820(void); +extern s32 func_801759D8(void); +extern void func_8017553C(s32 *param); +extern void func_801757A0(s32 a0); +extern short D_800B9A02; +extern void func_80175590(void *arg0); +extern s16 D_800B9A02; +extern void func_801757A0(s32); +extern void func_80175624(void *a0); +extern void func_801757E0(int); +extern void func_80175668(void); +extern void (*D_80190B1C[])(); +extern void func_80175690(s32 *param); +extern void func_80175DA8(s32 a0); +extern void func_80175AB8(s32 a0); +extern void func_80176144(s32 a0); +extern void func_801756E4(s32 arg0); +extern void func_80175798(void); +extern void func_80176734(s32 a0); +extern void func_80176218(s32 a0); +extern void func_80176D00(s32 a0); +extern void func_801757E0(s32 a0); +extern s32 func_80178004(s32 a0, s32 a1, s32 a2); +extern u8 D_8011F7B1; +extern u16 D_8011F7B4; +extern u16 D_8011F7B6; +extern s16 D_8011F81E; +extern void *func_80177784(void *a0, s32 a1, s32 a2, s32 a3); +extern u32 func_801783D0(s32 a0, s32 a1); +extern void *func_801777BC(void *a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6); +extern u16 D_8011F82C; +extern u16 D_8011F82A; +extern u32 * func_80176D94(void *param_1, u32 param_2, s16 param_3_); +extern void func_801778A8(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80176FF4(s32 a0); +extern u16 D_8011F830; +extern u16 D_8011F82E; +extern u32 * func_801770E0(void *param_1, u32 param_2, s16 param_3_); +extern void func_80177340(s32 a0); +extern u8 D_8011F837; +extern u8 D_8011F7F0; +extern u8 D_8011F7AB; +extern u32 * func_8017742C(u32 *param_1, s32 param_2, s32 param_3); +extern void func_801776EC(u8 *a0); +extern void * func_80177784(void *a0, s32 a1, s32 a2, s32 a3); +extern uint * func_80177EA4(uint *param_1, int param_2, uint param_3, int param_4); +extern void func_80177F84(s32 param_1, s32 param_2); +extern u32 * func_80178298(u32 *param_1, u8 *param_2, short param_3, short param_4); +extern M2C_UNK D_801E07F0; +extern void func_80178438(u16 *arg0); +extern void func_801787D4(void); +extern void func_8012A908(void); +extern void func_8017869C(s32 a0); +extern void func_80130D0C(s32 a0); +extern void func_8013E370(void); +extern s32 D_8011DB08; +extern void func_8017849C(void); +extern void func_8013E4B4(void); +extern s16 D_801270C4; +extern s32 D_801274D8; +extern s16 D_801270C2; +extern u8 D_801270C6; +extern u8 D_801270C7; +extern s32 D_801274DC; +extern s32 D_801274E0; +extern void func_80178608(void); +extern void func_80178744(s32 a0, s32 a1); +extern void func_80178840(); +extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2); +extern void func_8012E8E0(s32 a0, s32 a1); +extern void func_8012B2CC(s32 a0); +extern s32 func_801788B8(s32 arg0, s32 arg1); +extern s32 func_801789AC(s32 arg0); +extern s16 D_801E21F8; +extern int func_80178970(void); +extern s32 func_80178B18(s32 param_1, s32 param_2); +extern s32 func_80178B70(s32 param_1, s32 param_2); +extern void func_80178BB8(s32 a0, s32 a1); +extern s32 func_80178BF8(); +extern s32 D_801E1AE0; +extern short D_801E226C; +extern void func_80178CBC(s32 arg0, s32 arg1); +extern void func_80178D18(void); +extern s32 func_80178D40(s32 arg0, s32 arg1); +extern void func_80179B28(s32 a0); +extern void func_80179B74(u16 *p); +extern void func_80179D30(u16 *a0); +extern void func_80179D78(u16 *a0); +extern void func_80179DCC(short a0); +extern void func_80179DF8(void); +extern void func_80179E1C(short a0); +extern void func_80179E48(s16 a0); +extern void func_80179E74(s16 a0); +extern void func_80179EA0(u16 *a0); +extern void func_80179EE8(short a0); +extern void func_80179F14(s16 a0, s16 a1); +extern void func_80179F44(void); +extern void func_80179F6C(short a0); +extern void func_80179F98(u16 *a0); +extern void func_80179FEC(u16 *a0); +extern void func_8017A040(u16 *a0); +extern s32 D_801E1F0C; +extern void func_8017A094(s32 arg0); +extern void func_8017A0C4(s32 arg0); +extern void func_8017A0F4(void); +extern void func_8017A11C(void); +extern s32 D_801E1F34; +extern void func_8017A144(s32 a0); +extern void func_8017A180(void); +extern void func_8017A1A8(void); +extern void func_8017A1D0(void); +extern void func_8017A1F8(void); +extern void func_8017A220(void); +extern void func_8017A248(void); +extern void func_8017A270(void); +extern void func_8017A298(void); +extern void func_8017A2C0(void); +extern void func_8017A2E8(void); +extern void func_8017A310(void); +extern void func_8017A338(void); +extern void func_8017A360(void); +extern void func_8017A388(void); +extern s16 D_801E1EF0; +extern s32 func_8017A3B0(void); +extern short D_801E1F2C; +extern short D_801E1F28; +extern int func_800D0CA0(int); +extern int func_8001AAA0(s32 arg0); +extern int func_800D0CE0(void); +extern int func_8017A3D8(void); +extern void func_80172310(u8*); +extern void func_80172780(void*); +extern void func_80172894(void*); +extern void func_801729B0(s32); +extern void func_80172B14(s16); +extern void func_80172C50(u16 *); +extern void func_80172D68(s32); +extern void func_801733FC(s16, u16 *); +extern void func_80173460(s32, s32); +extern void func_801734BC(s32, s32); +extern void func_801736B0(s32, s32); +extern void func_801737B8(s16); +extern void func_801738DC(s16); +extern void func_80173A28(s32, s32, s32, s32, s32, s32); +extern void func_80174438(s32); +extern void func_8017A4AC(void); +extern s32 func_8017AD0C(s32 arg0); +extern s32 func_8017AD0C(s32); +extern s32 func_8017ADE8(s32 a0); +extern s32 func_8017AE08(void); +extern void func_8017B0E4(int param_1, int param_2); +extern s16 D_801E1EF4; +extern u16 D_801E1F74; +extern u16 D_801E1F76; +extern u16 D_801E1F78; +extern void func_8017B1D8(void); +extern s32 func_8017B238(s32 param_1, s32 param_2); +extern s32 func_8017B368(s32 param); +extern s32 func_8017B614(s32 param_1, s32 param_2); +extern s32 D_80114F30; +extern s32 D_80114F34; +extern s32 D_80114F38; +extern s32 D_80114F24; +extern s32 D_80114F28; +extern s32 D_80114F2C; +extern u8 D_8012694C; +extern s16 D_801E1F6C; +extern s16 D_801E1F6E; +extern s16 D_801E1F70; +extern s16 D_801E1F64; +extern s16 D_801E1F66; +extern s16 D_801E1F68; +extern void func_8017B7A8(void); +extern s16 D_801E1F84; +extern s16 D_801E1F86; +extern s16 D_801E1F88; +extern s16 D_801E1F8C; +extern s16 D_801E1F8E; +extern s16 D_801E1F90; +extern void func_8017B824(void); +extern void func_8017B880(void); +extern s32 func_8017B8E8(s32 src); +extern short D_801E1F7C; +extern short D_801E1F7E; +extern short D_801E1F80; +extern void func_8017B940(void); +extern void func_8012F214(s32 a0, s32 a1, s32 a2); +extern void func_80049CAC(s32 a0, s32 a1); +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern void RotTransSV(void *a0, void *a1, void *a2); +extern SV4 D_801E1F14; +extern SV4 D_801E1F1C; +extern void func_8017BA3C(s32 param_1, s32 param_2); +extern s32 func_8017BB34(s32 param_1, s32 param_2); +extern void (*D_801E1F3C[10])(int); +extern void func_8017BC38(int param_1); +extern void func_8017B0E4(int, int); +extern void func_8017BCA0(int param_1); +extern void func_8012A4BC(void); +extern void func_8017BCF4(int param_1); +extern void (*D_801E1F38)(void); +extern void func_8017BD50(int param_1); +extern void (*D_80190CF8[])(void); +extern void func_8017BE60(void *a0); +extern void func_8017BE9C(void); +extern void func_8017BEA4(void); +extern void func_8017BEAC(void); +extern void func_8017BEB4(void); +extern void func_8017BEBC(s32 arg0); +extern void (*D_80190DDC[])(void); +extern void func_8017CF14(void *a0); +extern void func_8017D224(void *a0); +extern s32 func_8017CF50(s32 a0); +extern s32 func_8017CF94(s32 a0); +extern void (*D_80190DE4[])(void); +extern void func_8017CFB8(void *a0); +extern void func_8017D24C(void); +extern s32 func_8017CFF4(s32 a0); +extern s32 func_8017D038(void); +extern void (*D_80190DEC[])(void); +extern void func_8017D05C(void *a0); +extern void func_8017D274(s32 a0); +extern s32 func_8017D098(s32 a0); +extern void func_8001BFD0(void); +extern void func_800D1E28(void); +extern s32 func_8017D0D8(u8 *a0); +extern void func_800D1EBC(void); +extern void func_8017D154(void *a0); +extern void (*D_80190DF8[])(void); +extern void func_8017D174(void *a0); +extern s32 func_8017D1B0(s32 a0); +extern void (*D_80190E20[])(void); +extern void func_8017D59C(void *a0); +extern s32 func_80012ABC(s32 a0, s32 a1, s32 a2); +extern void func_8017D9C0(s32 param_1, s16 *param_2); +extern void func_8017DB58(s32 a0); +extern void func_8013B7F4(s32 arg0); +extern s32 D_80190E40[]; +extern void func_8017DB74(int param_1); +extern void func_8017E2A8(int param_1); +extern void func_8012C218(void *a0); +extern void func_8017E2B0(void *arg0); +extern void (*D_80190F7C[])(void); +extern void func_8017E2F4(void *a0); +extern void (*D_80190F84[])(void); +extern void func_8017E40C(void *a0); +extern void func_8017EFD8(void *a0); +extern void (*D_80191058[])(void); +extern void func_8017F2D0(void *a0); +extern s32 func_8017F0D4(); +extern void func_8017F4B0(void); +extern void (*D_80191070[])(void); +extern void func_8017F4D0(void *a0); +extern void func_8012C1B8(void); +extern void func_8012CAE4(void *a0); +extern void func_8001C214(s32, s32); +extern u32 D_80191060; +extern void func_8017F50C(s32 arg0); +extern void func_8017F588(s32 arg0); +extern s32 func_8017F590(void *a0); +extern void func_8012DFD4(void *a0); +extern void func_8017F598(void *a0); +extern void func_8017F7FC(s32 arg0); +extern void func_8012AD44(s32 *a0, s16 a1); +extern void func_8017FED0(s32 a0); +extern void func_801800AC(s32 arg0); +extern void (*D_801AD3B4[])(void); +extern void func_80180310(void *a0); +extern void func_80180CB0(s32 arg0); +extern void (*D_801AD420[])(void); +extern void func_80180EA4(void *a0); +extern void func_80180F30(s32 target, u16 *cur, s32 step); +extern void (*D_801AD44C[])(void); +extern void func_80181168(void *a0); +extern void func_8012B23C(); +extern void func_801812F8(s32 a0); +extern code_fn D_801AD508[]; +extern s32 func_8012B414(s32 a0); +extern void func_801813C8(int param_1); +extern void func_80181418(s32 arg0); +extern void func_8018165C(s32 a0); +extern void func_801817D0(void); +extern void func_8012A828(s32 a0, void *a1); +extern void func_80181D70(s32 param_1); +extern void func_80181FA4(s32 param_1); +extern void func_8001C924(s32 a0, void *a1); +extern s32 func_8012BEE8(); +extern s32 func_8012B6D4(s16 *a0, s16 *a1); +extern s32 func_8012B608(s32 a0, s32 a1, s32 a2); +extern void func_8012B178(s32 a0, s32 a1); +extern s32 func_801856F0(s32 a0); +extern void func_80013350(s32 a0, void *a1); +extern void func_80182610(s32 p); +extern s32 func_8012BDBC(s32 a0, s32 a1); +extern void func_80142414(s32 a0, s16 a1); +extern void func_801828D8(s32 p); +extern void func_80182998(s32 param_1); +extern void func_801832FC(s32 param_1); +extern void func_80185878(s32 a0); +extern void func_8012F214(s32, s32, s32); +extern s32 func_8012BCCC(s32 a0); +extern s32 func_80187318(void *a0, s32 a1, s32 a2); +extern s32 func_8012BEE8(); /* TU-canonical: an earlier call site passes zero args */ +extern void func_801833B4(s32 p); +extern s32 func_8012B8E4(s32 a0, s32 a1); +extern void func_80187414(s32 a0, void *a1, void *a2, s32 a3); +extern void func_801873B0(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5); +extern s32 func_80132EF4(s32 a0, s32 a1); +extern void func_80049CAC(s32, s32); +extern void func_800484EC(s32, s32, s32); +extern s32 func_80187EF4(s32 arg0, u16 arg1); +extern void func_8018358C(s32 p); +extern s32 func_8012BEE8(s32 a0); +extern void func_8012B0B4(unsigned int *p, int a1, int a2); +extern s32 func_8012B744(void *a0, void *a1); +extern void func_80187414(s32, void*, void*, s32); +extern void func_801873B0(s32, void*, s32, s32, s32, s32); +extern s32 func_80013478(s32 a0, s32 a1); +extern void func_80183A20(s32 param_1); +extern void func_801850CC(); +extern void func_80183E3C(s32 arg0); +/* ==== end §8b carried decl layer ==== */ + + +extern void func_80184F88(s32 a0); +extern s32 func_8012DBD0(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80184E14(s32 a0, s32 a1); +extern void func_8012CC64(s32 a0, s32 a1); +extern s32 func_80143B6C(s32 a0, s32 a1); +extern s32 func_8012CBA4(s32 a0); +extern s32 func_8012CBF4(s32 a0); +extern void func_8012B23C(s32 a0); +extern void func_80131C78(s32 a0); +extern void func_80131E00(); +extern s32 func_80187EF4(s32 arg0, u16 arg1); + + +void func_80184A28(s32 a0) { + + extern u8 D_801BD2E4; + u16 sp10[4]; + s32 s1; + + if (*(s16 *)(a0 + 0xA) >= 0x10) { + func_80184F88(a0); + return; + } + + if (*(s32 *)(a0 + 0x10) != 0 || *(s32 *)(a0 + 0x18) != 0) { + func_8012DBD0(a0, 0x50, + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800, 0x1D); + } + + switch (*(u8 *)(a0 + 0xC2)) { + case 0: + func_80184E14(a0, (s32)&D_801BD2E4); + *(u8 *)(a0 + 0xC2) += 1; + case 1: + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) -= 0x100; + *(s32 *)(a0 + 0x1C) += 1; + if (*(s32 *)(a0 + 0x1C) >= 0x29) { + func_80131E00(a0, 0xD); + return; + } + s1 = ((s32 (*)(s32, s32))func_8012CC64)(a0, (s32)&D_801BD2E4); + if (s1 & 0x8000) { + *(s32 *)(a0 + 0x18) = 0; + *(s32 *)(a0 + 0x10) = 0; + } + if (s1 & 0x4000) { + func_8012B23C(a0); + *(u8 *)(a0 + 0xC2) = 4; + } else if (s1 & 0x2000) { + *(u8 *)(a0 + 0xC2) = 2; + func_80143B6C(a0, 1); + *(s32 *)(a0 + 0x14) = 0xFFF30000; + *(s32 *)(a0 + 0x1C) = 0; + ((s32 (*)())func_80187EF4)(a0, 0x9B8); + } + break; + + case 2: + { + s32 s2; + + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) -= 0x100; + *(s32 *)(a0 + 0x1C) += 1; + if (*(s32 *)(a0 + 0x1C) >= 0x29) { + func_80131E00(a0, 0xD); + return; + } + s2 = *(s32 *)(a0 + 0x14); + s1 = ((s32 (*)(s32, s32))func_8012CC64)(a0, (s32)&D_801BD2E4); + if (s1 & 0x8000) { + *(s32 *)(a0 + 0x18) = 0; + *(s32 *)(a0 + 0x10) = 0; + } + if (s1 & 0x4000) { + func_8012B23C(a0); + *(u8 *)(a0 + 0xC2) = 4; + } else if (s1 & 0x2000) { + func_80143B6C(a0, 1); + *(s32 *)(a0 + 0x14) = (-s2) / 3; + *(s32 *)(a0 + 0x1C) = 0; + *(u8 *)(a0 + 0xC2) = 3; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) = 0; + } + } + break; + + case 3: + *(s32 *)(a0 + 0x10) = *(s32 *)(a0 + 0x10) * 15 / 16; + *(s32 *)(a0 + 0x18) = *(s32 *)(a0 + 0x18) * 15 / 16; + if (*(u8 *)(a0 + 0xC3) & 1) { + s1 = func_8012CBA4(a0); + if (s1 & 0x8000) { + *(s32 *)(a0 + 0x18) = 0; + *(s32 *)(a0 + 0x10) = 0; + } + if (!(s1 & 0x6000)) { + func_80131E00(a0, 0xD); + return; + } + } else { + s1 = func_8012CBF4(a0); + if (s1 & 0x8000) { + *(s32 *)(a0 + 0x18) = 0; + *(s32 *)(a0 + 0x10) = 0; + } + if (s1 & 0x4000) { + func_8012B23C(a0); + *(u8 *)(a0 + 0xC2) = 4; + break; + } else if (s1 & 0x2000) { + *(u8 *)(a0 + 0xC3) |= 1; + ((s32 (*)())func_80187EF4)(a0, 0x9B8); + } + } + if ((*(s32 *)(a0 + 0x1C) & 3) == 3) { + func_80143B6C(a0, 1); + } + *(s32 *)(a0 + 0x1C) += 1; + if (*(s32 *)(a0 + 0x1C) < 0x11) { + break; + } + if (!(s1 & 0x6000)) { + func_80131E00(a0, 0xD); + return; + } + if (*(s16 *)(a0 + 0x76) <= 0) { + func_80131E00(a0, 6); + } else { + func_80131C78(a0); + } + break; + + case 4: + s1 = func_8012CBA4(a0); + if (s1 & 0x8000) { + *(s32 *)(a0 + 0x18) = 0; + *(s32 *)(a0 + 0x10) = 0; + } + if (s1 & 0x2000) { + if (*(s16 *)(a0 + 0x76) <= 0) { + func_80131E00(a0, 6); + } else { + func_80131C78(a0); + } + } else { + if ((*(s32 *)(a0 + 0x1C) & 3) == 3) { + func_80143B6C(a0, 1); + } + *(s32 *)(a0 + 0x1C) += 1; + if (*(s32 *)(a0 + 0x1C) >= 0x3D) { + func_80131E00(a0, 0xD); + return; + } + } + break; + } +} + + +/* §160g STEP 0 sibling hit: identical shape already matched inline inside + * func_80131340 (src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c and its dedup + * siblings), where the "delta" struct is a LOCAL computed earlier in that + * function. Here the delta is passed in directly via a1 — same struct-copy / + * add / dead-copy / call / subtract / store shape, adapted to a pointer + * parameter instead of a local. */ + +void func_80184E14(s32 a0, s32 a1) +{ + struct V8_80184E14 { + u16 vx, vy, vz, pad; + }; + extern s32 func_8012CEB0(void*, void*, s32); + + struct V8_80184E14 sp10; + struct V8_80184E14 sp18; + struct V8_80184E14 sp20; + + sp10.vx = *(u16 *)(a0 + 0x3A); + sp10.vy = *(u16 *)(a0 + 0x3E); + sp10.vz = *(u16 *)(a0 + 0x42); + sp18 = sp10; + sp18.vx += *(u16 *)(a1 + 0x0); + sp18.vy += *(u16 *)(a1 + 0x2); + sp18.vz += *(u16 *)(a1 + 0x4); + sp20 = sp18; /* load-bearing dead aggregate copy — gcc-2.7.2 has no aggregate DSE (§160e-family) */ + ((s32 (*)(s32, s32, s32))func_8012CEB0)((s32)&sp10, (s32)&sp18, 1); + sp18.vx -= *(u16 *)(a1 + 0x0); + sp18.vy -= *(u16 *)(a1 + 0x2); + sp18.vz -= *(u16 *)(a1 + 0x4); + *(u16 *)(a0 + 0x3A) = sp18.vx; + *(u16 *)(a0 + 0x3E) = sp18.vy; + *(u16 *)(a0 + 0x42) = sp18.vz; + *(u16 *)(a0 + 0x6) = sp18.vx; + *(u16 *)(a0 + 0xA) = sp18.vy; + *(u16 *)(a0 + 0xE) = sp18.vz; +} + + +extern s32 func_80187EF4(s32 arg0, u16 arg1); + void func_80184F68(s32 arg0) { + ((s32 (*)())func_80187EF4)(arg0, 0x9B7); + } + + +extern void func_8002AC00(s32 a0); +extern void func_8002A04C(s32 a0); +extern void func_8012C098(void *a0); + +void func_80184F88(s32 a0) +{ + switch (*(u16 *)(a0 + 0x70) & 0xF) { + case 0: + func_8002AC00(0x1F); + break; + case 1: + func_8002AC00(0x20); + break; + case 2: + func_8002AC00(0x21); + break; + } + func_8002A04C(a0); + func_8012C098((void *)a0); +} + + + +extern void func_801850CC(); +extern s32 func_80185578(s32 a0, s32 a1); +extern void func_8012A828(s32 a0, void *a1); + +void func_8018500C(s32 param_1) { + + extern s32 D_801D50C8; + u16 uVar1; + s32 iVar2; + + *(s16 *)(param_1 + 0x34) = 0; + if ((*(u32 *)(param_1 + 0xe0) & 8) == 0) { + func_801850CC(); + } else { + if ((*(u32 *)(param_1 + 0xe0) & 0x20) != 0) { + func_80185578(param_1, -0x8000); + } + *(s16 *)(param_1 + 2) = 0x22; + func_8012A828(param_1, &D_801D50C8); + } + iVar2 = *(s32 *)(param_1 + 0x20); + *(s16 *)(iVar2 + 0x14) = 0; + *(s16 *)(iVar2 + 0x10) = 0; + uVar1 = *(u16 *)(*(s32 *)(param_1 + 0x78) + 2); + *(u32 *)(param_1 + 0xe0) = (*(u32 *)(param_1 + 0xe0) & 0xffffffd5) | 0x400; + *(s16 *)(param_1 + 0x5e) = 0; + *(u16 *)(param_1 + 0xae) = *(u16 *)(param_1 + 0xae) & 0xfffe; + *(u32 *)(param_1 + 0xc4) = *(u32 *)(param_1 + 0xc4) & 0xfffffffb; + *(s16 *)(param_1 + 0x5c) = uVar1; +} + + +void func_801850CC(s32 a0) { + + extern u8 D_801D4E18[]; + extern u8 D_801D4140[]; + extern s32 D_801BD154[]; + extern s32 D_801BD164[]; + s32 flags; + + flags = *(s32 *)(a0 + 0xE0); + if (flags & 4) { + goto L_bit4; + } + if (flags & 0x800) { + *(u16 *)(a0 + 2) = 0xE; + func_8012A828(a0, D_801D4E18); + return; + } + if (flags & 1) { + goto L_tbl154; + } + if (*(s32 *)(a0 + 0xD0) == 0) { + goto L_tbl154; + } + *(u16 *)(a0 + 2) = 0xE; + *(u16 *)(a0 + 0x34) = 2; + *(s32 *)(a0 + 0x1C) = 0x200; + func_8012A828(a0, D_801D4140); + return; + +L_tbl154: + *(u16 *)(a0 + 2) = D_801BD154[*(u16 *)(a0 + 0x70) & 0xF]; + return; + +L_bit4: + *(u16 *)(a0 + 2) = D_801BD164[*(u16 *)(a0 + 0x70) & 0xF]; + func_8012A828(a0, D_801D4E18); + *(s32 *)(a0 + 0x1C) = 0x200; +} + + +extern void func_8012EC04(s32 param_1, s32 param_2, s32 *param_3); +extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5); +extern s32 func_80135888(s32 a0, s32 a1, s32 a2, s32 a3); + +s32 func_801851C4(s32 param_1, s32 param_2) +{ + + extern s32 *D_80126B78; + extern s32 *D_80126B90; + extern u8 D_801BD2EC[]; + s32 buf[8]; + s16 v1[4]; + s32 v2[4]; + s16 scratch[4]; + s16 sVar1; + + func_8012EC04(param_1, 0xB, buf); + gte_SetRotMatrix(buf); + gte_SetTransMatrix(buf); + RotTransSV(D_801BD2EC, v1, scratch); + RotTransSV(D_801BD2EC + 8, v2, scratch); + if (func_80135888((s32)D_80126B78, (s32)D_80126B90, (s32)v1, (s32)v2) != 0) { + sVar1 = *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12); + func_8012F568(1, 1, sVar1, param_2, (s32)v2, (s32)D_801152A8); + return 1; + } + return 0; +} + + + + +extern s32 func_8012BCCC(s32 a0); +extern s32 func_80187460(s32 a0, s32 a1); +extern void func_8012F214(s32, s32, s32); +extern s32 func_80187318(void *a0, s32 a1, s32 a2); + +/* Two load-bearing constructs (do NOT "clean up"): + * 1. `goto ret0` / `goto store` with `ret0:` placed BEFORE the store block — cookbook L1344 + * shared-ret0 goto. A trailing `return 0` makes gcc sink the merged ret0 tail past the + * store block (7 mismatches: BRANCH-POLARITY + swapped tail). + * 2. `register s32 r __asm__("$2")` on the func_80187460 result + `return r`. Plain + * `return 0;` there emits `set v0,0; j epi`, which cross_jump (§5a) merges into the + * ret0 block, so the branch lands on ret0 instead of the epilogue. Pinning r to $v0 + * makes `return r` a self-copy that dies before jump2, leaving a bare `j epi` that + * jump.c collapses into `beqz $v0, .L8018730C`. (A plain `s32 r` does NOT work — cse2 + * const-folds `r` to 0 on the fall-through edge and the merge comes back.) */ +s32 func_801852E4(s32 p) { + + extern s32 D_80126B9C; + extern u8 D_801BD0BC[]; + s32 buf10[2]; + s32 r; + + if ((*(u32 *)(p + 0xE0) & 1) == 0) { + goto ret0; + } + if (*(u16 *)(p + 2) == 1) { + goto ret0; + } + if (*(u16 *)(p + 2) == 0xD) { + return 0; + } + if ((D_80126B9C & 2) == 0) { + return 0; + } + if (0x10000 < func_8012BCCC(p)) { + return 0; + } + r = func_80187460(p, 0x380); + if (r == 0) { + goto out; + } + ((void (*)(s32, void *, void *))func_8012F214)(p, D_801BD0BC, buf10); + if (func_80187318(buf10, *(s16 *)(*(s32 *)(p + 0x20) + 0x12), 0x380) != 0) { + goto store; + } +ret0: + return 0; +store: + *(u16 *)(p + 2) = 0xC; + r = 1; +out: + return r; +} + + + +/* func_801853B4 — walk the 0x60-entry / 0x10C-stride entity table D_801202A0 and + * react to the first neighbour of class 0x27A (get pushed away from it) or 0x2F4 + * (get clamped down onto it). + * + * §71 sibling-first: the callee signatures below are copied VERBATIM from this TU's + * own already-matched neighbours — func_8012B0B4 (TU L6971/7855/8177), func_8012B6D4 + * (TU L6419), func_8012CEB0 (TU L7226, the func_80187844 block), func_8012C098 + * (TU L5379) — and D_801202A0 is the TU's file-scope `extern u8 D_801202A0[];` (L384). + * func_8012BC60 / func_8012ADE4 are not declared in this TU; the forms below are the + * fleet-majority shapes (func_8012ADE4 verbatim; func_8012BC60 with `void *` instead of + * `struct Vec *` so the draft does not depend on engine_types.h being in scope). + * + * FIVE load-bearing constructs (do NOT "clean up"): + * + * 1. NO SECOND WALKED POINTER. All of +0x6/+0xA/+0xE are written as `*(T *)(p + k)` + * off the single biv `p`. combine_givs then merges the three DEST_ADDR givs onto + * ONE anchor = the LAST-emitted one (+0xE, from the case-0x2F4 `lh`), giving the + * target's `$s3 = $s2 + 0xE` with -0x8/-0x4/0x0 displacements. + * An explicit `q = p + 0xE` with `*(u16 *)q` looks equivalent and is NOT: + * gcc-2.7.2 excludes a bare `*q` (mult 1, add 0) from givs (find_mem_givs:4198), + * so q stays a live biv AND the remaining two accesses combine onto their own + * anchor +0xA => THREE IVs, the wrong anchor, and the $s6 hoist lost to pressure + * (measured: 111 ins, 87 mismatched). gcc-2.7.2-map/loop.md §L1 rules 4 & 6. + * + * 2. `switch`, not `if/else if`. The two-case switch is what emits the target's + * compare CHAIN with BOTH arms out of line (`beq`/`beq`/`j default`, 6 slots). + * An `if (id == 0x27A) ... else if (id == 0x2F4)` inverts the first test and lets + * the 0x27A arm fall through — 2 instructions short. + * + * 3. do-while with `i++` BEFORE `p += 0x10C`. strength_reduce inserts the reduced + * giv's `addiu` immediately before ITS biv's increment, so the source order + * i-then-p is what produces `addiu $s4,$s4,1` / `addiu $s3,$s3,0x10C` / + * (delay) `addiu $s2,$s2,0x10C`. A `for (i = 0; i < 0x60; i++)` with `p += 0x10C` + * last puts the giv add first and swaps the pair. + * + * 4. `self4` and `sc` are REAL pre-loop locals, in that order. Both are loop + * invariants; written inline as `(s16 *)(a0 + 4)` / `(unsigned int *)sp20` at the + * call, combine folds the address straight into the argument move + * (`addiu $a0,$sp,0x20`) and the target's `$s6 = $sp + 0x20` hoist never happens. + * Assigning them in a *different basic block* from their uses is what keeps the + * pseudos alive; the declaration ORDER (p, i, self4, sc) is what gives + * $s2/$s4/$s5/$s6 in the target's prologue emission order. + * + * 5. `s16 y` (a SHORT local), and `s32 sp20[2]` (an EIGHT-byte scratch). + * - The short local is why `y` gets a second pseudo: gcc-2.7.2 emits + * `(set (reg:HI B) (subreg:HI (reg:SI A)))` for the HImode assignment, i.e. the + * target's `addu $a1,$a0,$zero` in the branch delay slot, with the two `- 0x60` + * recomputed from A ($a0, the compare) and B ($a1, the stored value). + * An `s32 y` coalesces the pair away and loses that instruction. + * - The short local also costs a DEAD 4-byte reload home at the top of the frame + * (`(use (mem:SI (plus $sp 48)))` in the greg dump, no insn references it). + * That is exactly why the func_8012B0B4 buffer is 8 bytes, not 16: 0x10 + 8 + * (v10) + 8 (v18) + 8 (sp20) + 4 (dead) rounds to 0x30 = the target's first + * saved-register slot. 8 bytes also matches the fleet's canonical shape for a + * func_8012B0B4 output buffer (`unsigned int buf[2]`). + */ + + +extern s32 func_8012BC60(void *a0, void *a1); +extern s32 func_8012B6D4(s16 *a0, s16 *a1); +extern void func_8012B0B4(unsigned int *p, int a1, int a2); +extern s32 func_8012CEB0(void *a0, void *a1, s32 a2); +extern void func_8012ADE4(u8 *a0); +extern void func_8012C098(void *param_1); + +void func_801853B4(s32 a0) { + + extern u8 D_801202A0[]; + u8 *p; + s16 *self4; + unsigned int *sc; + s32 i; + s16 y; + s32 z; + s32 ang; + s16 v10[4]; /* sp+0x10 */ + s16 v18[4]; /* sp+0x18 */ + s32 sp20[2]; /* sp+0x20 — func_8012B0B4 output */ + + p = D_801202A0; + i = 0; + self4 = (s16 *)(a0 + 4); + sc = (unsigned int *)sp20; + do { + if ((u8 *)a0 != p) { + switch (*(u16 *)p) { + case 0x27A: + if (func_8012BC60((void *)self4, (void *)(p + 4)) < 0x6400) { + ang = func_8012B6D4(self4, (s16 *)(p + 4)); + func_8012B0B4(sc, ang, 0xA1); + v18[0] = *(u16 *)(p + 6); + v18[1] = *(u16 *)(p + 0xA); + v18[2] = *(u16 *)(p + 0xE); + v18[0] += sp20[0]; + v18[2] += sp20[0] >> 16; + v18[1] = *(u16 *)(a0 + 0xA); + v10[0] = *(u16 *)(a0 + 0x3A); + v10[1] = *(u16 *)(a0 + 0x3E); + v10[2] = *(u16 *)(a0 + 0x42); + if ((func_8012CEB0(v10, v18, 0) & 0x2000) == 0) { + func_8012ADE4((u8 *)a0); + return; + } + *(u16 *)(a0 + 6) = v18[0]; + *(u16 *)(a0 + 0xA) = v18[1]; + *(u16 *)(a0 + 0xE) = v18[2]; + return; + } + break; + case 0x2F4: + y = *(s16 *)(p + 0xE); + z = *(s16 *)(a0 + 0xE); + if (y + 0x10 < z) { + func_8012C098((void *)a0); + return; + } + if (y - 0x60 < z) { + *(s16 *)(a0 + 0xE) = y - 0x60; + } + break; + } + } + i++; + p += 0x10C; + } while (i < 0x60); +} + + + + +/* SIMULATION of real-TU context: the TU carries these two rows before the def */ +extern s32 func_80185578(s32 a0, s32 a1); +extern s32 func_80185578(s32 a0, s32 a1); + +s32 func_80185578(s32 arg0, s32 arg1) { + extern u8 D_801BD0C4[]; + extern s32 D_801BD2FC[]; + extern u8 D_800D3918[]; + extern void func_80187414(s32 a0, void *a1, void *a2, s32 a3); + extern void func_801873B0(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5); + extern void func_8001C924(s32 a0, void *a1); + u8 buf[8]; + s16 y = arg1; + s32 res; + s16 state; + s32 flags; + + state = *(u16 *)(arg0 + 0x70) & 0xF; + flags = *(u32 *)(arg0 + 0xE0); + if (flags & 4) { + return 0; + } + switch (state) { + case 0: + if (flags & 1) { + func_80187414(arg0, D_801BD0C4, buf, 0xC); + res = ((s32 (*)(s32, void *, s32, s32, s32, s32))func_801873B0)(arg0, buf, 0x27F, (s16)arg1, 0, 0); + *(s32 *)(arg0 + 0xD0) = res; + *(u32 *)(arg0 + 0xE0) &= ~1; + if (res != 0) { + *(u16 *)(arg0 + 0xEE) = *(u16 *)(res + 0x36); + } + } + /* fallthrough */ + case 1: + case 2: + case 3: + func_80187414(arg0, D_800D3918, buf, 0xB); + res = ((s32 (*)(s32, void *, s32, s32, s32, s32))func_801873B0)(arg0, buf, 0x27F, (s16)(y | (state + 1)), 0, 0); + *(s32 *)(arg0 + 0xCC) = res; + *(u32 *)(arg0 + 0xE0) |= 4; + func_8001C924(*(s32 *)(arg0 + 0x20), (void *)D_801BD2FC[state]); + if (res != 0) { + *(u16 *)(arg0 + 0xEC) = *(u16 *)(res + 0x36); + } + break; + default: + return 1; + } + return 1; +} + + +extern s32 func_8012CBA4(s32 a0); +extern void func_80185750(s32 a0, s32 a1); +extern void func_8012ADE4(u8 *a0); + +s32 func_801856F0(s32 a0) { + s32 s0; + s32 t; + + s0 = func_8012CBA4(a0); + func_80185750(a0, s0); + if (s0 & 0x2000) { + t = s0 & 0x8000; + return t == 0; + } + func_8012ADE4((u8 *)a0); + return 0; +} + + + +/* Family exemplar (S48 wave-4). Two compiler-shape levers used, both already + * documented in the cookbook: + * - §164z (func_8018A974 refutation): a non-volatile `__asm__("" ::: "memory")` + * barrier forces a genuine second `lw` reload of *(a0+0x90) at the C/D-group + * check, matching the target's register-clash reload, at zero extra stack cost. + * - §45 Lever 4: the call is written literally duplicated in each of the three + * arms rather than shared through one fall-through tail; gcc-2.7.2's jump.c + * cross-jumps the duplicates back together, which is what lets `addiu $a0,$zero,0x53` + * (not the unrelated stack-arg constant 0x14) win both branch-delay slots. + */ + +extern s32 func_801469C8(int, void*, int, int, u16, int, int, int); + +void func_80185750(s32 a0, s32 a1) { + + extern u8 D_801D4140[]; + extern u8 D_801D4B00[]; + extern u8 D_801D4BF8[]; + extern u8 D_801D47C0[]; + extern u16 D_800B99DA; + if ((*(s16 *)(a0 + 0x70) & 0x8000) == 0) { + return; + } + if ((a1 & 0xFF) != 0x24) { + return; + } + + if (*(u8 **)(a0 + 0x90) == D_801D4140) { + if (D_800B99DA % 3 == 0) { + ((s32 (*)(int, void *, int, int, s32, int, int, int))func_801469C8)(0x53, (void *)a0, *(s16 *)(a0 + 6), (s16)(*(u16 *)(a0 + 0xA) - 0xA0), + *(s16 *)(a0 + 0xE), 0, 0, 0x14); + } + } else if (*(u8 **)(a0 + 0x90) == D_801D4B00 && *(u16 *)(a0 + 2) == 0xB) { + ((s32 (*)(int, void *, int, int, s32, int, int, int))func_801469C8)(0x53, (void *)a0, *(s16 *)(a0 + 6), (s16)(*(u16 *)(a0 + 0xA) - 0xA0), + *(s16 *)(a0 + 0xE), 0, 0, 0x14); + } else { + if ((*(u8 **)(a0 + 0x90) == D_801D4BF8 || *(u8 **)(a0 + 0x90) == D_801D47C0) && + D_800B99DA % 6 == 0) { + ((s32 (*)(int, void *, int, int, s32, int, int, int))func_801469C8)(0x53, (void *)a0, *(s16 *)(a0 + 6), (s16)(*(u16 *)(a0 + 0xA) - 0xA0), + *(s16 *)(a0 + 0xE), 0, 0, 0x14); + } + } +} + + +void func_80185878(s32 a0) { + extern s32 func_801858D8(s32 a0, s32 a1); + + if (func_801858D8(a0, 2) == 0) { + *(s32 *)(a0 + 0xE8) += 0x40; + } else { + *(s32 *)(a0 + 0xE8) -= 0x40; + } + *(s32 *)(a0 + 0xE0) |= 0x40; +} + + + +/* func_801858D8 — line-of-sight / collision probe. + * + * Rotate the direction SVECTOR D_801BD30C[dir] through the entity's matrix + * (*(0x20) + 0x34) into a scratch SVECTOR at sp+0x10, build the segment + * start (sp+0x18) = entity pos and end (sp+0x20) = entity pos + rotated + * vector, then hand the pair to func_8012CEB0 / func_800132BC. + * + * §71 sibling-first: DEFINE_func_80169408 / DEFINE_func_8016986C in + * src/shared/engine_core.h are the house shape for this ApplyMatrixSV + + * SVECTOR-local family — `s16 vNN[4]` locals declared in ASCENDING stack + * offset order (sp+0x10, sp+0x18, sp+0x20) and the entity position read as + * `*(u16 *)(s1 + 0x6 / 0xA / 0xE)` (which is what makes the loads `lhu`). + * + * The target stores each of sp+0x20/0x22/0x24 TWICE — a plain copy first, + * then the copy plus the rotated component — so the source assigns the + * position, then `+=` the delta as separate statements (the local's address + * is taken, so gcc-2.7.2 cannot kill the first store). + */ + +extern void ApplyMatrixSV(void *a0, void *a1, void *a2); +extern s32 func_8012CEB0(void *a0, void *a1, s32 a2); +extern s32 func_800132BC(void *a0, void *a1); + +s32 func_801858D8(s32 a0, s32 a1) { + + extern s16 D_801BD30C[][4]; + extern s32 D_801E1FB0; + s32 s0 = a0; + s16 v10[4]; /* sp+0x10 SVECTOR — ApplyMatrixSV out */ + s16 v18[4]; /* sp+0x18 SVECTOR — segment start */ + s16 v20[4]; /* sp+0x20 SVECTOR — segment end */ + s32 r; + + ApplyMatrixSV((void *)(*(s32 *)(s0 + 0x20) + 0x34), D_801BD30C[a1], v10); + v18[0] = *(u16 *)(s0 + 0x6); + v18[1] = *(u16 *)(s0 + 0xA); + v18[2] = *(u16 *)(s0 + 0xE); + v20[0] = *(u16 *)(s0 + 0x6); + v20[1] = *(u16 *)(s0 + 0xA); + v20[2] = *(u16 *)(s0 + 0xE); + v20[0] = v20[0] + v10[0]; + v20[1] = v20[1] + v10[1]; + v20[2] = v20[2] + v10[2]; + r = func_8012CEB0(v18, v20, 0); + D_801E1FB0 = func_800132BC(v18, v20); + return r != 0x2000; +} + + + +extern void (*D_801BD34C[])(void); + +void func_801859B8(void *a0) { + D_801BD34C[*(u16 *)((s32)a0 + 0x2)](); +} + + + +/* + * func_801859F4 — "spawn init" state handler. + * + * Sibling-search hit (cookbook §160g): func_8018523C + * (src/ov_SC03_119/ov_SC03_119_jr_8017FB84.c) shares the exact opening + * idiom — func_8012C1B8() -> store result to a0+0x20 -> if zero, + * ((void (*)(s32))func_8012CAE4)(a0); return; else func_8001C214(v0, TABLE[idx]) — and the + * same shared-engine-core template also lives at + * src/shared/engine_core.h:10060 DEFINE_func_80144A98(). Both establish the + * house style used here: `extern void func_8012C1B8(void);` called through + * a `(s32 (*)(void))` cast (the canonical decl elsewhere is void-returning; + * §161c — cast at the call site rather than fighting it), and + * func_8012CAE4/func_8001C214 declared exactly as they already appear + * in this TU (grep hits at src/ov_SC06_018/ov_SC06_018_jr_80186270.c + * lines 2783/2790/2849/2895/2896). + * + * D_811BD33C is stored by ADDRESS only (lui/addiu, no lw) — §160f array + * declaration to force the address-only store. + * + * The three `lhu ...,0x70($s1); andi ...,0xF` sequences are NOT cached in + * a local — the target re-loads/re-masks independently at the array index, + * the ==4 compare, and the ==5 compare (three separate `lhu+andi` pairs in + * the .s), so the raw expression is repeated at each site rather than + * hoisted into one named temp. + */ + +void func_801859F4(void *a0) { + extern void func_8012C1B8(void); + extern void func_8012CAE4(void*); + extern void func_8001C214(s32 a0, s32 a1); + extern void func_80049CAC(s32 a0, s32 a1); + extern void func_800484EC(s32 a0, s32 a1, s32 a2); + extern s32 rand(void); + extern s32 D_801BD324[]; + extern u8 D_811BD33C[]; + + s16 buf[16]; /* sp+0x10 — output of func_80049CAC / input to func_800484EC */ + s16 rv[3]; /* sp+0x30 — random SVECTOR-ish {x,y,z} */ + s32 w[3]; /* sp+0x38 — {0, 0, 0xFFE80000} scratch handed to func_800484EC */ + s32 v0; + s32 m; + + v0 = ((s32 (*)(void))func_8012C1B8)(); + *(s32 *)((s32)a0 + 0x20) = v0; + if (v0 == 0) { + ((void (*)(s32))func_8012CAE4)((s32)a0); + return; + } + + func_8001C214(v0, D_801BD324[*(u16 *)((s32)a0 + 0x70) & 0xF]); + + *(u16 *)((s32)a0 + 0x10A) = *(u16 *)(*(s32 *)((s32)a0 + 0x64) + 0x36); + + if ((*(u16 *)((s32)a0 + 0x70) & 0xF) == 4) { + *(s32 *)(*(s32 *)((s32)a0 + 0x20) + 0x20) = (s32)D_811BD33C; + } + + if ((*(u16 *)((s32)a0 + 0x70) & 0xF) == 5) { + *(s16 *)((s32)a0 + 0x2) = 2; + return; + } + + w[1] = 0; + w[0] = 0; + w[2] = -0x180000; + m = rand() % 0x80; + if ((rand() & 1) == 0) { + rv[0] = m - 0x380; + } else { + rv[0] = -0x380 - m; + } + + rv[1] = *(u16 *)(*(s32 *)(*(s32 *)((s32)a0 + 0x64) + 0x20) + 0x12) + 0x800; + rv[2] = 0; + func_80049CAC((s32)rv, (s32)buf); + + func_800484EC((s32)buf, (s32)w, (s32)a0 + 0x10); + + *(s32 *)((s32)a0 + 0x48) = 0x18000; + *(u16 *)((s32)a0 + 0xFC) = rand() & 0xF0; + *(u16 *)((s32)a0 + 0xFE) = rand() & 0x7F; + *(u16 *)((s32)a0 + 0x100) = rand() & 0x30; + *(s32 *)((s32)a0 + 0x1C) = 0; + *(u16 *)((s32)a0 + 0x2) = *(u16 *)((s32)a0 + 0x2) + 1; +} + + +typedef struct { u8 b[4]; } Blk4_80185D4C; +typedef struct { s16 vx, vy, vz, pad; } SVec_80186E9C; /* 8 bytes, align 2 -> lwl/lwr block move */ +typedef struct { s32 a; s32 b[4]; } OtBlk_8018A974_8018EB08_8018A28C; /* == engine_types.h OtBlk (0x14) */ + +/* ov_SC06_018 :: func_80185B80 — actor state machine, jump-table switch on the + * u16 state word at +0x34. Jump table = jtbl_801D3AF0 (6 entries, 0..5), which + * is DEFINED in asm/ov_SC06_018/data/tail18.data.s — this .s carries no data of + * its own (§160c), so plain `extern`s are correct here. + * + * Family exemplar: reach x6. Keys (all byte-forced, do NOT "clean up"): + * + * (1) §161a — the table is indexed from ZERO (`lhu 0x34 ; sltiu <6 ; sll 2`, no + * `addiu -1`) and jtbl entry[0] = 0x80187B3C is a REAL body, so `case 0:` + * carries the first arm. No empty `case 0: break;` construction is needed + * (that idiom is only for tables whose entry[0] is the epilogue). + * + * (2) `s32 pad[1];` is LOAD-BEARING. The target frame is 0x20 (args 0x10 + + * ra/s0 at 0x18/0x1C) but nothing else ever touches $sp — i.e. the original + * had one more local that optimisation left unreferenced. Without it the + * frame compiles to 0x18 and the 6 prologue/epilogue immediates are wrong. + * Size matters: 4 bytes -> 0x20 (right), 8 bytes -> 0x28 (wrong). + * Same idiom as func_80187DD0 in this TU (`s32 pad[2];`). + * + * (3) Case 0's 0x102 write must be TWO separate stores in an if/else, not + * `uVar = 0x400; if (...) uVar = 0xC00; store;`. With a live temp gcc keeps + * the value in $a0 and reuses it for the later `+0x400`; the target instead + * re-LOADS `lhu 0x102($s0)`. Two stores kill the temp, the cross-jumper + * re-merges the single `sh`, and the reload comes back (cf. §160d). + * + * (4) Case 0's `iVar >= 4` test is written the "wrong" way round on purpose: + * the >= 4 arm is the fall-through in the target, the div arm is the branch + * target. Writing `if (iVar < 4) {div} else {...}` swaps the two blocks. + * + * (5) Case 1 re-reads `*(s16 *)(param_1 + 0x70)` at BOTH tests instead of using + * one local. A local gives `andi $v0,$v1,0x8000` (dir kept in $v1, 184 + * ins); the two reads make cse copy the loaded value out first — + * `addu $v0,$v1,$zero ; andi $v1,$v1,0x8000` — which is the 185th + * instruction and also lets the delay-slot filler steal `andi $v1,$v0,0xF`. + * + * (6) func_8012CC40 is fleet-canonical `void`; its $v0 is used here, so it is + * called through a cast (§17a-1) rather than being re-declared. + */ + +extern void func_8012CC40(s32 arg0, s32 arg1); /* fleet-canonical: void; $v0 used -> cast at use */ +extern s32 func_80143B6C(s32 a0, s32 a1); /* fleet-canonical */ +extern s32 func_8012B608(s32 a0, s32 a1, s32 a2); +extern s32 func_8012BEE8(s32 a0); +extern void func_8012E8C4(u8 *a0); +extern void func_8012E8A8(u8 *a0); +extern void func_80187094(s32 a0, s32 a1); +extern s32 func_801874E0(s32 a0, s32 a1, s32 a2); +extern void func_8012C218(void *a0); + +extern u8 D_801BD358; + +void func_80185B80(s32 param_1) +{ + s32 iVar; + s32 t; + u16 st; + u16 uVar1; + s32 pad[1]; /* see key (2): forces the 0x20 frame — never referenced */ + + if (0xf < *(s16 *)(param_1 + 0xA)) { + func_8012C218((void *)param_1); + return; + } + switch (*(u16 *)(param_1 + 0x34)) { + case 0: + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + *(u16 *)(param_1 + 0xFC); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + *(u16 *)(param_1 + 0xFE); + if ((((s32 (*)(s32, s32))func_8012CC40)( + param_1, + ((*(u16 *)(param_1 + 0x70) & 0xF) * 8) + (s32)&D_801BD358) & + 0x2000) == 0) { + return; + } + iVar = *(s32 *)(param_1 + 0x1C) + 1; + *(s32 *)(param_1 + 0x1C) = iVar; + if (iVar >= 4) { + if ((*(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) & 0xFFFU) > 0x800U) { + *(u16 *)(param_1 + 0x102) = 0xC00; + } else { + *(u16 *)(param_1 + 0x102) = 0x400; + } + t = *(u16 *)(param_1 + 0x70) & 0xF; + if (t < 4 && t != 0) { + *(u16 *)(param_1 + 0x102) = *(u16 *)(param_1 + 0x102) + 0x400; + } + *(s32 *)(param_1 + 0x1C) = 0x1E; + *(u16 *)(param_1 + 0x34) = *(u16 *)(param_1 + 0x34) + 1; + } else { + *(s32 *)(param_1 + 0x14) = -(0x80000 / iVar); + func_80143B6C(param_1, 1); + } + return; + case 1: + iVar = func_8012B608((s32)*(s16 *)(*(s32 *)(param_1 + 0x20) + 0x10), + (s32)*(s16 *)(param_1 + 0x102), 4); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + iVar; + if (func_8012BEE8(param_1) == 0) { + return; + } + st = *(u16 *)(param_1 + 0x34); + *(s32 *)(param_1 + 0x1C) = 0x1E; + *(u16 *)(param_1 + 0x34) = st + 1; + if ((*(s16 *)(param_1 + 0x70) & 0x8000) != 0) { + *(u16 *)(param_1 + 0x34) = st + 2; + } else if ((*(s16 *)(param_1 + 0x70) & 0xF) == 4) { + *(u16 *)(param_1 + 0x34) = 4; + *(s32 *)(param_1 + 0x1C) = 0x1E; + } + return; + case 2: + func_8012E8C4((u8 *)param_1); + if (func_8012BEE8(param_1) == 1) { + func_8012C218((void *)param_1); + } + return; + case 3: + if (*(s16 *)(*(s32 *)(param_1 + 0x64) + 0x36) != *(s16 *)(param_1 + 0x10A) && + *(s32 *)(param_1 + 0xE0) == 0) { + *(s32 *)(param_1 + 0x1C) = 0x1E; + uVar1 = 2; + if ((*(u16 *)(param_1 + 0x70) & 0xF) == 4) { + uVar1 = 4; + } + *(u16 *)(param_1 + 0x34) = uVar1; + *(s32 *)(param_1 + 0xE0) = 1; + } + return; + case 4: + if (func_8012BEE8(param_1) != 0) { + *(s32 *)(param_1 + 0x1C) = 0xA; + *(u16 *)(param_1 + 0x34) = *(u16 *)(param_1 + 0x34) + 1; + func_8012E8A8((u8 *)param_1); + func_80187094(param_1, 1); + } + return; + case 5: + if (func_801874E0(param_1, 0x60, 0xA0) == 1) { + func_8012C218((void *)param_1); + } + return; + } +} + + + +extern void func_8012C218(void *a0); +extern void func_8012E8A8(u8 *a0); + +/* §48-C2: lwl/lwr/swl/swr block copy == a plain struct assign of a 2-byte-aligned struct */ + +void func_80185E64(s32 param_1) +{ + s32 t1 = *(s32 *)(param_1 + 0x64); + s32 pad[2]; + + if (*(s16 *)(t1 + 0x36) != *(s16 *)(param_1 + 0x10A)) { + func_8012C218((void *)param_1); + return; + } + { + if ((*(u32 *)(t1 + 0xE0) & 4) != 0) { + func_8012E8A8((u8 *)param_1); + return; + } + { + s32 a2 = *(s32 *)(*(s32 *)(t1 + 0x20) + 0x20); + s32 a3 = param_1 + 0xFC; + + if (a2 != 0) { + if ((a2 & 0x1000000) != 0) { + s32 a1 = a2 & 0xFEFFFFFF; + register u32 v0 __asm__("$2"); // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus9) + u32 a0; + u32 v1a; + u32 v1b; + u32 v0b; + u32 v1; + + *(u16 *)(param_1 + 0x102) = *(u16 *)(a1 + 0x66); + + v0 = *(u32 *)(a1 + 0x60); + a0 = *(u8 *)(a1 + 0x61); + v1a = (v0 & 0xF) << 8; + a0 = a0 | v1a; + v1b = ((s32)v0 >> 16) & 0xFF; + v0b = (v0 & 0xF0) << 4; + v1 = v1b | v0b; + *(u16 *)(param_1 + 0x104) = (u16)a0; + *(u16 *)(param_1 + 0x106) = (u16)v1; + + *(s16 *)(param_1 + 0xFC) = (s8)*(u8 *)(a1 + 0x63); + *(s16 *)(param_1 + 0xFE) = (s8)*(u8 *)(a1 + 0x64); + *(s16 *)(param_1 + 0x100) = (s8)*(u8 *)(a1 + 0x65); + } else { + *(UAlign12_80185E64 *)(param_1 + 0xFC) = *(UAlign12_80185E64 *)(a2 + 0x90); + } + *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x20) = a3; + } + + if ((*(u32 *)(t1 + 0xE0) & 0x80) != 0) { + if (*(u16 *)(param_1 + 0x34) == 0) { + s16 sVar2 = *(u16 *)(param_1 + 0x108) + 0x40; + *(s16 *)(param_1 + 0x108) = sVar2; + if (sVar2 > 0x200) { + *(u16 *)(param_1 + 0x108) = 0x200; + *(s16 *)(param_1 + 0x34) = *(s16 *)(param_1 + 0x34) + 1; + } + } else { + u16 uVar3 = *(u16 *)(param_1 + 0x108) - 0x80; + *(u16 *)(param_1 + 0x108) = uVar3; + if ((s16)uVar3 < 0) { + *(u16 *)(param_1 + 0x108) = 0; + *(u16 *)(param_1 + 0x34) = 0; + *(u32 *)(t1 + 0xE0) = *(u32 *)(t1 + 0xE0) & ~0x80; + } + } + } + + *(u16 *)(a3 + 6) = *(u16 *)(a3 + 6) + *(u16 *)(param_1 + 0x108); + + *(u32 *)(param_1 + 4) = *(u32 *)(t1 + 4); + *(u32 *)(param_1 + 8) = *(u32 *)(t1 + 8); + *(u32 *)(param_1 + 0xC) = *(u32 *)(t1 + 0xC); + + *(UAlign8_80185E64 *)(param_1 + 0x50) = *(UAlign8_80185E64 *)(t1 + 0x50); + + { + s32 dst = *(s32 *)(param_1 + 0x20); + s32 src = *(s32 *)(t1 + 0x20); + *(UAlign8_80185E64 *)(dst + 0x10) = *(UAlign8_80185E64 *)(src + 0x10); + } + { + s32 dst = *(s32 *)(param_1 + 0x20); + s32 src = *(s32 *)(t1 + 0x20); + *(UAlign8_80185E64 *)(dst + 0x18) = *(UAlign8_80185E64 *)(src + 0x18); + } + { + s32 src = *(s32 *)(t1 + 0x20); + s32 dst = *(s32 *)(param_1 + 0x20); + *(u32 *)(dst + 4) = *(u32 *)(src + 4); + } + { + s32 src = *(s32 *)(t1 + 0x20); + s32 dst = *(s32 *)(param_1 + 0x20); + *(u16 *)(dst + 0x2C) = *(u16 *)(src + 0x2C); + } + } + } +} + + + +extern void (*D_801BD4A4[])(void); + +void func_8018611C(void *a0) { + D_801BD4A4[*(u16 *)((s32)a0 + 0x2)](); +} + + +extern int func_8012C354(); +extern s32 func_80143994(s32 a0, s32 a1); +extern u8 D_801BD388[]; +extern u8 D_801BD3B4[]; +extern u8 D_801BD3E8[]; +extern void func_8001CA1C(s32 a0, s32 a1); +extern void func_8012C1B8(void); +extern void func_8012CAE4(); +extern void func_801862C8(s32 a0); +extern void func_80186B94(s32 p); + +void func_80186158(s32 a0) { + s32 v1; + s32 obj; + + v1 = *(u16 *)(a0 + 0x70) & 0xF; + switch (v1) { + case 0: + if (func_8012C354(a0, D_801BD3B4) == 0) { + return; + } + *(s32 *)(*(s32 *)(a0 + 0x20) + 0x20) = a0 + 0xE8; + *(u16 *)(a0 + 0x104) = 0x78; + func_801862C8(a0); + func_80143994(a0, 0x1800); + return; + case 1: + if (func_8012C354(a0, D_801BD3E8) == 0) { + return; + } + *(u16 *)(a0 + 0x104) = 0xA0; + if ((*(s16 *)(a0 + 0x70) & 0x8000) == 0) { + *(s16 *)(a0 + 0x2) = 3; + return; + } + *(s16 *)(a0 + 0x2) = 5; + func_80143994(a0, 0x1800); + return; + case 2: + obj = ((s32 (*)(void))func_8012C1B8)(); + *(s32 *)(a0 + 0x20) = obj; + if (obj == 0) { + func_8012CAE4(a0); + return; + } + func_8001CA1C(obj, (s32)D_801BD388); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x18) = 0x14CC; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1199; + *(s32 *)(*(s32 *)(a0 + 0x20) + 4) |= 0x58000000; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) |= 0x10; + func_80186B94(a0); + return; + default: + return; + } +} + + +extern void func_8012B2CC(s32 a0); +extern void func_8012B178(s32 a0, s32 a1); + +void func_801862C8(s32 param_1) { + *(s32 *)(param_1 + 0x1C) = 0x18; + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = 0x80; + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x12); + func_8012B2CC(param_1); + func_8012B178(param_1, -0x100000); + *(u16 *)(param_1 + 2) = 2; +} + + + +extern void func_8012C218(void *a0); +extern s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_80187094(s32 a0, s32 a1); +extern s32 func_8012B8E4(s32 a0, s32 a1); +extern s32 func_8012BEE8(s32 a0); +extern s32 func_8012B608(s32 a0, s32 a1, s32 a2); +extern s32 func_8012CBF4(s32 a0); +extern void func_8012B178(s32 a0, s32 a1); +extern u8 *func_8012913C(s32 a0); +extern void func_8012F214(s32 a0, s32 a1, s32 a2); + + +void func_80186330(s32 param_1) { + + extern u8 D_801BD41C; + extern u8 D_801BD4D0[]; + extern u16 D_80126CB4; + extern u16 D_80126CB6; + extern u16 D_80126CB8; + u16 uVar1; + + if (0xf < *(s16 *)(param_1 + 0xA)) { + func_8012C218((void *)param_1); + return; + } + + { + s32 base = (s32)&D_801BD41C; + s32 r = func_8012D5E4(param_1, base, base + 8, 0x78); + if (r == 1 || (*(u16 *)(param_1 + 0x5C) & 1) != 0) { + func_80187094(param_1, 1); + func_8012C218((void *)param_1); + return; + } + } + + uVar1 = *(u16 *)(param_1 + 0x34); + switch (uVar1) { + default: + return; + case 0: + { + s32 sVar3 = func_8012B608((s32)*(s16 *)(*(s32 *)(param_1 + 0x20) + 0x10), 0, 0x18); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + sVar3; + } + { + s32 r = func_8012CBF4(param_1); + if (r != 0) { + goto LAB_8018847c; + } + } + { + s32 r = func_8012BEE8(param_1); + if (r == 0) return; + } + *(u16 *)(param_1 + 0xF4) = D_80126CB4; + *(u16 *)(param_1 + 0xF6) = D_80126CB6; + { + u16 tmp = D_80126CB8; + *(u16 *)(param_1 + 0x34) = *(u16 *)(param_1 + 0x34) + 1; + *(s32 *)(param_1 + 0x1C) = 0x3C; + *(u16 *)(param_1 + 0xF8) = tmp; + } + return; + case 1: + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) += func_8012B8E4(param_1, 0x20); + { + s32 r = func_8012BEE8(param_1); + if (r != 0) { + *(s32 *)(param_1 + 0x1C) = 0x5A; + *(u16 *)(param_1 + 0x34) = *(u16 *)(param_1 + 0x34) + 1; + } + } + break; + case 2: + break; + } + + *(u16 *)(param_1 + 0xF2) = *(u16 *)(param_1 + 0xF2) - 0x100; + func_8012B178(param_1, 0xFFEC0000); + { + s32 r = func_8012CBF4(param_1); + if (r != 0) goto LAB_8018847c; + } + if (*(u16 *)(param_1 + 0x34) != 2) goto LAB_80188494; + { + s32 r = func_8012BEE8(param_1); + if (r != 1) goto LAB_80188494; + } +LAB_8018847c: + *(u16 *)(param_1 + 2) = 9; + func_80187094(param_1, 1); + return; +LAB_80188494: + { + s32 iv = (s32)func_8012913C(0x80); + if (iv == 0) return; + { + u16 out[4]; + ((void (*)(s32, void *, void *))func_8012F214)(param_1, D_801BD4D0, out); + *(u16 *)(iv + 6) = out[0]; + *(u16 *)(iv + 0xA) = out[1]; + *(u16 *)(iv + 0xE) = out[2]; + } + return; + } +} + + +extern void func_8012B2CC(s32 a0); +extern void func_8012B178(s32 a0, s32 a1); + +void func_80186588(s32 param_1) { + *(s32 *)(param_1 + 0x48) = 0xC000; + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x12); + func_8012B2CC(param_1); + func_8012B178(param_1, 0x20000); + *(s16 *)(param_1 + 2) = 4; + *(s32 *)(param_1 + 0x1C) = 0; + *(u16 *)(param_1 + 0x34) = 0; +} + + + +extern void func_8012C218(void *a0); +extern s32 func_8012BD14(s32 a0); +extern s32 func_8012BEE8(s32 a0); +extern void func_8012CC64(s32 a0, s32 a1); /* fleet-canonical: void; $v0 used -> cast at use */ +extern s32 func_80143B6C(s32 a0, s32 a1); /* fleet-canonical */ +extern void func_80187094(s32 a0, s32 a1); + + +void func_801865E8(s32 param_1) { + + extern u8 D_801BD43C; + s32 v0; + s32 iVar; + + if (0xf < *(s16 *)(param_1 + 0xA)) { + func_8012C218((void *)param_1); + return; + } + v0 = func_8012BD14(param_1); + if (v0 < 0x1001) { + goto LAB_tail; + } + if (*(u16 *)(param_1 + 0x34) == 0) { + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) - 0x40; + v0 = ((s32 (*)(s32, s32))func_8012CC64)(param_1, (s32)&D_801BD43C); + if ((v0 & 0x2000) == 0) { + return; + } + iVar = *(s32 *)(param_1 + 0x1c) + 1; + *(s32 *)(param_1 + 0x1c) = iVar; + if (iVar >= 4) { + u16 tmp = *(u16 *)(param_1 + 0x34); + *(s32 *)(param_1 + 0x1c) = 0xA; + *(u16 *)(param_1 + 0x34) = tmp + 1; + return; + } + *(s32 *)(param_1 + 0x14) = -(0x80000 / iVar); + func_80143B6C(param_1, 1); + return; + } + if (func_8012BEE8(param_1) != 1) { + return; + } +LAB_tail: + *(u16 *)(param_1 + 2) = 9; + func_80187094(param_1, 0); +} + + +void func_80186720(s32 arg0) { + s32 temp = *(s32 *)(arg0 + 0x64); + *(s16 *)(arg0 + 0x2) = 6; + *(s16 *)(arg0 + 0x34) = 0; + *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(temp + 0x20) + 0x12); +} + + + +// @class: struct +// @stuck: none — MATCH (276 ins, relocation-masked). Verified BOTH standalone (match_one) and +// spliced into src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c (whole-TU cc1 -O2 clean, +// masked structured_diff 0/276). +// Keys: (1) the first func_8012C218 call gets a NOP delay slot because reload_cse_regs deletes the +// redundant `move a0,s1` -- $a0 still holds the incoming param on the fall-through path +// (no CODE_LABEL between the prologue and the jal). The second call site is behind a +// label, so the move survives. Source is the natural `func_8012C218((void *)param_1)` at +// BOTH sites -- do NOT write a zero-arg call (it also breaks in-TU: the composite type +// from the earlier file-scope `extern void func_8012C218(void *a0);` rejects 0 args). +// (2) case 0's guard is an `||` with an early return -- that is what puts `beqz -> fail` then +// `beq -> ok` (an `&&` would emit `bne -> fail`). +// (3) `register s32 sVar2 __asm__("$2")` holds the p+0x34 reload in cases 1/2 so the two arms +// cross-jump into the shared .L80188928 tail. +// (4) `__asm__ __volatile__("")` after the func_8012C658 arm forces the `lw v1,0x1C(s1)` +// reload before the cross-jumped `li v0,9` (§21 zero-byte re-tie). +// (5) `-((iVar3 << 0x10) / 0x22)` reproduces the 0x78787879/sra-4 magic-divide by 34 + negu. +// (6) `*p * 0xc` then `>>4` with the manual `if (x<0) x+=0xf` is the /16 rounding form. + +extern void func_8012C218(void *a0); +extern void func_80187414(s32, void*, void*, s32); +extern s32 func_80013328(s32 a0, s32 a1); +extern void func_8012B14C(s32 a0, s32 a1); +extern void func_8012CC64(s32 a0, s32 a1); /* fleet-canonical: void; $v0 used -> cast at use */ +extern s32 func_8012C658(s32, s32, s32); +extern s32 func_80143B6C(s32 a0, s32 a1); /* fleet-canonical */ +extern s32 func_8012BEE8(s32 a0); +extern void func_80016714(void*, s32); +extern void func_80187094(s32 a0, s32 a1); + + +void func_80186744(s32 param_1) { + + extern u8 D_801D51D0; + extern u8 D_801BD444; + extern u8 D_801BD44C; + extern u8 D_801BD43C; + extern u8 D_80126B5C; + u16 uVar1; + s32 sVar2; + s32 iVar3; + s32 iVar4; + s32 iVar5; + u32 uVar4; + s32 psVar5; + u16 buf[8]; + s32 vec[3]; + + if (0xf < *(s16 *)(param_1 + 0xA)) { + func_8012C218((void *)param_1); + return; + } + uVar1 = *(u16 *)(param_1 + 0x34); + switch (uVar1) { + case 0: + psVar5 = *(s32 *)(param_1 + 0x64); + if ((*(u16 *)psVar5 == 0) || + (*(s32 *)(psVar5 + 0x90) != (s32)&D_801D51D0)) { + func_8012C218((void *)param_1); + return; + } + if (*(s32 *)(psVar5 + 0x94) < 0x11) { + ((void (*)(void *, void *, void *, s32))func_80187414)((void *)psVar5, (void *)&D_801BD444, buf, 5); + *(s16 *)(param_1 + 6) = buf[0]; + *(s16 *)(param_1 + 0xA) = buf[1]; + *(s16 *)(param_1 + 0xE) = buf[2]; + return; + } + ((void (*)(void *, void *, void *, s32))func_80187414)((void *)psVar5, (void *)&D_801BD44C, buf, 4); + ((void (*)(void *, void *, void *, s32))func_80187414)((void *)psVar5, (void *)&D_801BD44C, &buf[4], 5); + *(s16 *)(param_1 + 6) = + (s16)((*(s16 *)&buf[0] + *(s16 *)&buf[4]) >> 1); + *(s16 *)(param_1 + 0xA) = + (s16)((*(s16 *)&buf[1] + *(s16 *)&buf[5]) >> 1); + *(s16 *)(param_1 + 0xE) = + (s16)((*(s16 *)&buf[2] + *(s16 *)&buf[6]) >> 1); + if (*(s32 *)(psVar5 + 0x94) != 0x19) { + return; + } + *(u16 *)(param_1 + 0x34) = *(u16 *)(param_1 + 0x34) + 1; + vec[0] = 0; + vec[1] = 0xfff40000; + iVar3 = func_80013328((s32)&D_80126B5C, param_1 + 4); + vec[2] = -((iVar3 << 0x10) / 0x22); + func_8012B14C(param_1, (s32)vec); + *(s32 *)(param_1 + 0x48) = 0xc000; + return; + case 1: + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + 0x80; + iVar3 = ((s32 (*)(s32, s32))func_8012CC64)(param_1, (s32)&D_801BD43C); + if (iVar3 == 0) { + return; + } + *(s32 *)(param_1 + 0x1c) = 0; + *(u16 *)(param_1 + 0x34) = (*(u16 *)(param_1 + 0x34)) + 1; + return; + case 2: + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + 0x40; + uVar4 = ((s32 (*)(s32, s32))func_8012CC64)(param_1, (s32)&D_801BD43C); + if ((uVar4 & 0x2000) == 0) { + return; + } + iVar4 = *(s32 *)(param_1 + 0x1c) + 1; + *(s32 *)(param_1 + 0x1c) = iVar4; + if (iVar4 >= 4) { + sVar2 = *(u16 *)(param_1 + 0x34); + *(s32 *)(param_1 + 0x1c) = 0x1e; + *(u16 *)(param_1 + 0x34) = sVar2 + 1; + return; + } + iVar3 = *(s32 *)(param_1 + 0x10) * 0xc; + if (iVar3 < 0) { + iVar3 = iVar3 + 0xf; + } + *(s32 *)(param_1 + 0x10) = iVar3 >> 4; + iVar5 = *(s32 *)(param_1 + 0x18) * 0xc; + if (iVar5 < 0) { + iVar5 = iVar5 + 0xf; + } + *(s32 *)(param_1 + 0x18) = iVar5 >> 4; + *(s32 *)(param_1 + 0x14) = -(0x80000 / *(s32 *)(param_1 + 0x1c)); + func_80143B6C(param_1, 1); + return; + case 3: + uVar4 = *(u32 *)(param_1 + 0x1c); + if ((uVar4 - 0xe < 0xb) && ((uVar4 & 1) == 0)) { + ((void (*)(s32, s32, s32))func_8012C658)(0x2a8, (s32)*(s16 *)(param_1 + 0x104), param_1); + do { *(u16 *)(param_1 + 0x104) = *(u16 *)(param_1 + 0x104) + 1; } while (0); + uVar4 = *(u32 *)(param_1 + 0x1c); + } + if (uVar4 == 9) { + *(u32 *)(*(s32 *)(param_1 + 0xcc) + 4) = + *(u32 *)(*(s32 *)(param_1 + 0xcc) + 4) & 0x7fffffff; + *(s16 *)(*(s32 *)(param_1 + 0xcc) + 8) = *(u16 *)(param_1 + 6); + *(s16 *)(*(s32 *)(param_1 + 0xcc) + 0xa) = + *(u16 *)(param_1 + 0xa) - 0x24; + *(s16 *)(*(s32 *)(param_1 + 0xcc) + 0xc) = *(u16 *)(param_1 + 0xe); + } + if (*(s32 *)(param_1 + 0x1c) - 4U < 6) { + *(s16 *)(*(s32 *)(param_1 + 0xcc) + 0x18) = + *(u16 *)(*(s32 *)(param_1 + 0xcc) + 0x18) + 0x200; + *(s16 *)(*(s32 *)(param_1 + 0xcc) + 0x1a) = + *(u16 *)(*(s32 *)(param_1 + 0xcc) + 0x1a) + 0x200; + } + iVar3 = func_8012BEE8(param_1); + if (iVar3 != 1) { + return; + } + ((void (*)(s32, s32))func_80016714)(*(s32 *)(param_1 + 0xcc), 0x38); + *(s16 *)(param_1 + 2) = 9; + func_80187094(param_1, 0); + return; + } + return; +} + + + +extern void func_80049CAC(s32, s32); +extern void func_800484EC(s32, s32, s32); +extern void func_8012B260(u8 *a0); + +void func_80186B94(s32 p) { + s32 g10[4]; /* sp+0x10 */ + u16 g20[4]; /* sp+0x20 */ + s32 buf28[8]; /* sp+0x28 */ + u16 v; + + g10[2] = 0xFFF00000; + g10[1] = 0; + g10[0] = 0; + g20[0] = 0x10; + v = *(u16 *)(*(s32 *)(*(s32 *)(p + 0x64) + 0x20) + 0x12) + + *(u16 *)(p + 0xFC); + g20[1] = v; + *(u16 *)(p + 0xFE) = v; + g20[2] = 0; + ((void (*)(void *, void *))func_80049CAC)(g20, buf28); + ((void (*)(void *, void *, s32))func_800484EC)(buf28, g10, p + 0x10); + *(u16 *)(p + 2) = 8; + *(s32 *)(p + 0x1C) = 0x40; + ((void (*)(s32))func_8012B260)(p); +} + + +extern SVECTOR D_801BD42C[]; +extern s32 func_8012BEE8(); +extern s32 func_8012CBF4(s32 a0); +extern s32 *D_80126B78; +extern s32 *D_80126B90; +extern s32 func_80132EF4(s32 a0, s32 a1); +extern s32 func_80135888(s32 a0, s32 a1, s32 a2, s32 a3); +extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6); +extern u8 D_801152A8[]; +extern void func_80049CAC(s32 a0, s32 a1); +extern void func_8012C218(void *a0); +extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5); + +void func_80186C30(s32 param_1) +{ + MATRIX mat; + SVECTOR sv; + SVECTOR b; + SVECTOR c; + SVECTOR flag; + s32 iVar; + + sv.vx = *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10); + sv.vy = *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12); + sv.vz = 0; + func_80049CAC((s32)&sv, (s32)&mat); + + gte_SetRotMatrix(&mat); + gte_SetTransMatrix(*(s32 *)(param_1 + 0x20) + 0x34); + + RotTransSV(&D_801BD42C[0], &b, &flag); + RotTransSV(&D_801BD42C[1], &c, &flag); + + if (func_80135888((s32)D_80126B78, (s32)D_80126B90, (s32)&b, (s32)&c) != 0) { + s16 sVar1 = *(s16 *)(param_1 + 0xFE); + func_8012F568(1, 1, sVar1, 0x50, (s32)&c, (s32)D_801152A8); + } else { + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) - 0x100; + iVar = func_8012CBF4(param_1); + if (iVar != 0) { + s16 sVar1 = *(s16 *)(param_1 + 6); + s16 sVar2 = *(s16 *)(param_1 + 0xA); + s16 sVar3 = *(s16 *)(param_1 + 0xE); + func_80146A6C(6, (void *)param_1, sVar1, sVar2, sVar3, 0, 0); + iVar = func_80132EF4(param_1, 0x22); + if (iVar != 0) { + *(u16 *)(iVar + 0x34) = 0x2000; + } + } else { + iVar = func_8012BEE8(param_1); + if (iVar == 0) { + return; + } + } + } + func_8012C218((void *)param_1); +} + + + + +extern void func_8012E8A8(u8*); + +void func_80186DE8(void *a0) +{ + ((void (*)(void *))func_8012E8A8)(a0); + *(u32 *)(a0 + 0x1C) = 0xA; + *(u16 *)(a0 + 0x5C) = 0; + *(u16 *)(a0 + 0x2) = 0xA; +} + + + + +void func_80186E24(s32 a0) +{ + extern s32 func_8012D624(s32 a0, s32 a1, s32 a2); + extern s32 func_801874E0(s32 a0, s32 a1, s32 a2); + extern void func_8012C218(void *a0); + extern u16 D_80126B96; + + if (*(u16 *)(a0 + 0x70) & 1) { + if (func_8012D624(a0, 0x60, *(s16 *)(a0 + 0x104)) == 1) { + D_80126B96 = 0x4001; + } + } + if (func_801874E0(a0, 0x60, *(s16 *)(a0 + 0x104)) == 1) { + func_8012C218((void *)a0); + } +} + + + +/* func_80186EA4 @ ov_SC06_018 (subseg ov_SC06_018_jr_8017C24C) — 124 ins. MATCH. + * + * GATE: .venv/bin/python tools/match_one.py func_80186EA4 \ + * --c .run/wave-s40/ov_SC06_018/func_80186EA4.c \ + * --asm-subdir asm/ov_SC06_018/nonmatchings/ov_SC06_018_jr_8017C24C + * + * ------------------------------------------------------------------ what it is + * "Try to hand this object off to another live entity of kind 0x282." + * 1. Build two 8-byte position vectors off `self` via func_8012F214 (the + * fleet's local->world transform; see the ov_SC02_026 walker family, + * e.g. src/ov_SC03_103/ov_SC03_103_jr_8017C294.c:4106 func_8017EC0C, which + * is the byte-matched sibling this draft's types were lifted from). + * 2. Keep a third copy of the destination vector (`c = b`) — 8 bytes at + * align 2, so gcc emits the inline lwl/lwr + swl/swr block move, exactly + * the "8 bytes, align 2 -> lwl/lwr/swl/swr copy" note carried in that + * sibling. This is why `c` must be a STRUCT ASSIGN, not a memcpy. + * 3. If the global-collision probe func_80135888(D_80126B78, D_80126B90, &a, &b) + * says the move is blocked, punt to func_8012F568 and return 1. + * 4. Otherwise walk the 0x60-entry / 0x10C-stride entity table D_801202A0 + * looking for a 0x282 entity that (a) matches `kind` (or, when + * kind == 0xFFFF, only self->f70), (b) is not `self`, and (c) passes the + * same collision probe against its own f20/f58 volumes. First hit gets + * state 9 and func_80187094(e, 0); return 1. No hit -> 0. + * + * ---------------------------------------------------------------- the levers + * L1 ARG 5 IS A `u16` (stack slot 0x60(sp) read with `lhu`). The redundant + * `andi $v1,$s2,0xffff` in the target is gcc's zero_extendhisi2 for the + * HImode->SImode widening at `kind != 0xFFFF`; it comes free with a plain + * ANSI `u16` param and CANNOT be reproduced from an `s32`/`s16` param. + * That same zero-extended $v1 is then reused as the loop compare operand + * (`addu $s4,$v1,$zero`), which is why the kind test inside the loop must + * be written against `kind` itself and not a re-cast copy. + * + * L2 `i` MUST BE INITIALISED IN EACH LOOP'S for-INIT, NOT ONCE BEFORE THE + * `if`. This is the whole match. <-- the only residual v1 had. + * With `e = ...; i = 0; if (kind != 0xFFFF) {...}` the draft is 124/124 + * instructions with FOUR bytes wrong: `kind` lands in $s4 instead of $s2 + * (and the two prologue `sw`s swap slots to follow it). Reason (regalloc.md + * K3/K5, class RC-3): `kind` is the lowest-density allocno (2 refs over a + * ~50-insn range) so it is assigned LAST, and find_reg then takes the + * LOWEST-numbered non-conflicting callee-saved register. Hoisting `i = 0` + * above the `andi` that reads `kind` makes `i`'s live range OVERLAP + * `kind`'s, so $s2 becomes a conflict and $s4 is the next free slot. + * Sinking `i = 0` into both for-inits removes the overlap -> $s2. + * The single `addu $s2,$zero,$zero` you see in the delay slot of the + * `beq` is dbr: it lifts the fall-through arm's `i = 0` into the slot and + * drops the other arm's copy as redundant (both arms set it before any + * use, so it is safe on both paths). Do NOT "simplify" it back to one + * shared initialiser — that is the 4-byte regression. + * + * L3 THE ARMS ARE `!=` FIRST. `if (kind != 0xFFFF) {kind-or-self loop} + * else {self-only loop}` gives `beq $v1,$v0,` with the kind-aware + * loop falling through, which is the target order. Writing it as + * `if (kind == 0xFFFF)` emits `bne` and swaps the two bodies. + * + * L4 BOTH ARMS' HIT-BLOCKS ARE TEXTUALLY IDENTICAL, which lets jump.c's + * cross-jump tail-merge collapse them: the second loop's + * `bnez $v0,.L80188F5C` branches into the FIRST loop's + * `sh 9; jal func_80187094; return 1` block. Keep them identical. + * + * L5 LOCAL DECL ORDER IS THE FRAME LAYOUT (regalloc.md K1/K7): `a`,`b`,`c` + * land at 0x18 / 0x20 / 0x28, immediately above the 0x18-byte outgoing-arg + * area that func_8012F568's 6 arguments force. Frame 0x50. Reordering + * the three declarations shifts every sp displacement. + * + * L6 `e != self` is a POINTER compare against the `self` param (`beq $s1,$s3`), + * so `self` must be typed as the same Ent pointer, not an s32. + * + * ---------------------------------------------------------------- banking note + * The real TU src/ov_SC06_018/ov_SC06_018_jr_8017C24C.c already declares + * `extern u8 D_801202A0[];` (L384), `extern s32 func_80135888(s32,s32,s32,s32);` + * (L589), `extern void func_8012F214(s32,s32,s32);` (L2641), + * `extern void func_80187094(s32 a0, s32 a1);` (L7388, and DEFINES it at L7711) + * and `extern u8 D_801152A8[];` (L598) — all fleet-canonical and identical to + * the spellings below, so only the two `D_80126B7 8/90` pointer externs + * (canonical form `extern s32 *D_80126B78;`, 3297 fleet occurrences) and the + * two local typedefs need to travel. Uniquify the typedef names per §120 if + * the TU already carries a V4/Ent (it carries neither of these two spellings). + * + * SIBLINGS (the 5 other h_norm members): every DATA symbol this body touches — + * D_801202A0, D_801152A8, D_80126B78, D_80126B90 — is RESIDENT (fixed VA, not + * per-overlay tail.data), and three of the four callees (func_8012F214, + * func_80135888, func_8012F568) are resident too. The ONLY per-overlay symbol + * is func_80187094, and in this overlay it is defined in the SAME TU + * (ov_SC06_018_jr_8017C24C.c:7711). So the §40 remap for the siblings is + * expected to be near-identity: re-point func_80187094 at each sibling's own + * address and check that sibling TU's canonical spellings for the four externs + * before sweeping (§56b — carry the TU's types, not this draft's). + */ + +typedef struct { u16 x, y, z, w; } V4_80188E10_80186EA4; + +typedef struct { + u16 f0; /* 0x00 entity kind; 0x282 is the one we want */ + s16 f2; /* 0x02 state -> 9 on a hit */ + u8 p04[0x20 - 0x04]; + s32 f20; /* 0x20 collision volume A */ + u8 p24[0x58 - 0x24]; + s32 f58; /* 0x58 collision volume B */ + u8 p5C[0x70 - 0x5C]; + s16 f70; /* 0x70 sub-kind / owner tag */ + u8 p72[0x10C - 0x72]; /* stride 0x10C, 0x60 entries (0x6480) */ +} Ent_80188E10_80186EA4; + +extern void func_8012F214(s32 a0, s32 a1, s32 a2); +extern s32 func_80135888(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5); +extern void func_80187094(s32 a0, s32 a1); + + +s32 func_80186EA4(Ent_80188E10_80186EA4 *self, s32 arg1, s32 arg2, s32 arg3, u16 kind) { + + extern s32 *D_80126B78; + extern s32 *D_80126B90; + extern u8 D_801202A0[]; + V4_80188E10_80186EA4 a; /* 0x18(sp) */ + V4_80188E10_80186EA4 b; /* 0x20(sp) */ + V4_80188E10_80186EA4 c; /* 0x28(sp) */ + Ent_80188E10_80186EA4 *e; + s32 i; + + func_8012F214((s32)self, arg1, (s32)&a); + func_8012F214((s32)self, arg2, (s32)&b); + c = b; /* L2: lwl/lwr block move */ + if (func_80135888((s32)D_80126B78, (s32)D_80126B90, (s32)&a, (s32)&b) != 0) { + func_8012F568(1, 1, *(s16 *)(self->f20 + 0x12), arg3, (s32)&b, (s32)D_801152A8); + return 1; + } + e = (Ent_80188E10_80186EA4 *)D_801202A0; + if (kind != 0xFFFF) { /* L3 */ + for (i = 0; i < 0x60; i++, e++) { /* L2: i=0 HERE, not above */ + if (e->f0 == 0x282 && (e->f70 == kind || e->f70 == self->f70) && e != self && + func_80135888(e->f20, e->f58, (s32)&a, (s32)&c) != 0) { + e->f2 = 9; /* L4: keep identical */ + func_80187094((s32)e, 0); + return 1; + } + } + return 0; + } else { + for (i = 0; i < 0x60; i++, e++) { /* L2 */ + if (e->f0 == 0x282 && e->f70 == self->f70 && e != self && + func_80135888(e->f20, e->f58, (s32)&a, (s32)&c) != 0) { + e->f2 = 9; /* L4: keep identical */ + func_80187094((s32)e, 0); + return 1; + } + } + return 0; + } +} + + + +extern s32 func_80132EF4(s32 a0, s32 a1); +extern void func_8012B0B4(unsigned int *p, int a1, int a2); +extern void func_80049CAC(s32, s32); +extern void func_800484EC(s32, s32, s32); +extern s32 func_8012C658(s32, s32, s32); +extern s32 func_80187EF4(s32 arg0, u16 arg1); +extern s32 rand(void); + +void func_80187094(s32 a0, s32 a1) { + s32 buf10[8]; /* sp+0x10 (0x20) - func_80049CAC out / func_800484EC in */ + s32 g40[4]; /* sp+0x30, only [0..2] used - func_800484EC vec3 arg */ + u16 g30[4]; /* sp+0x40, only [0..2] used - func_80049CAC vec3 arg */ + unsigned int buf48[2]; /* sp+0x48 (8) - func_8012B0B4 output */ + unsigned int *p48; + s32 i; + s32 baseY; + s32 e; + u32 uVar; + s32 scratch; + s32 tmp; + + i = 0; + p48 = buf48; + baseY = 0x100; + do { + e = func_80132EF4(a0, 0x23); + if (e != 0) { + *(s16 *)(e + 0x34) = rand() % 0x4000 + 0x1000; + *(u16 *)(*(s32 *)(e + 0x20) + 0x2c) = 0xc008; + + func_8012B0B4(p48, rand() % 0x1000, rand() % 0x58); + + tmp = *(s32 *)buf48; + *(s16 *)(e + 6) = *(s16 *)(e + 6) + (s16)tmp; + *(s16 *)(e + 0xe) = *(s16 *)(e + 0xe) + (s16)(tmp >> 16); + + tmp = rand(); + scratch = tmp % 0x80; + uVar = rand(); + g30[0] = (uVar & 1) == 0 ? -scratch + 0x400 : scratch + 0x400; + + scratch = rand() % 0xc0; + uVar = rand(); + g30[1] = (uVar & 1) != 0 ? baseY + scratch : baseY - scratch; + + g30[2] = 0; + g40[1] = 0; + g40[0] = 0; + g40[2] = (rand() % 4 + 3) << 16; + + ((void (*)(void *, void *))func_80049CAC)(g30, buf10); + ((void (*)(void *, void *, s32))func_800484EC)(buf10, g40, e + 0x10); + } + i++; + baseY += 0x200; + } while (i < 8); + + e = func_80132EF4(a0, 0x23); + if (e != 0) { + *(u16 *)(e + 0x34) = 0x7ff1; + *(u16 *)(*(s32 *)(e + 0x20) + 0x2c) = 0xc004; + *(s32 *)(e + 0x14) = 0xfffb0000; + } + + i = 0; + do { + func_8012C658(0x29d, (u16)a1, a0); + i++; + } while (i < 4); + + ((s32 (*)())func_80187EF4)(a0, 0x95e); +} + + +typedef struct { u8 d[4]; } __attribute__((packed, aligned(1))) B4_8018C334; + + +s32 func_80187318(void *a0, s32 a1, s32 a2) { + extern u16 D_80126B5E; + extern u16 D_80126B62; + extern u16 D_80126B66; + extern s32 func_8012B70C(s16 *a0, s16 *a1); + u16 buf[3]; + s32 d; + + buf[0] = D_80126B5E; + buf[1] = D_80126B62; + buf[2] = D_80126B66; + d = (func_8012B70C((s16 *)a0, (s16 *)buf) - (s16)a1) & 0xFFF; + if (d < 0x800) { + return d < (s16)a2; + } else { + return (0x1000 - d) < (s16)a2; + } +} + + +extern s32 func_8012C51C(void *a0, s32 a1); + +typedef struct { + u16 f10; /* 0x10 */ + u16 f12; /* 0x12 */ + u16 f14; /* 0x14 */ + s16 f16; /* 0x16 */ + s16 f18; /* 0x18 */ + s16 f1a; /* 0x1A */ + s16 f1c; /* 0x1C */ + u16 f1e; /* 0x1E */ + s32 f20; /* 0x20 */ +} buf_801873B0; + +void func_801873B0(a0, a1, a2, a3, a4, a5) +s32 a0; +void *a1; +s32 a2; +s32 a3; +u16 a4; +s32 a5; +{ + buf_801873B0 sp; + u16 t; + + sp.f10 = *(u16 *)a1; + sp.f12 = *(u16 *)(2 + (char *)a1); + t = *(u16 *)(4 + (char *)a1); + sp.f16 = a2; + sp.f18 = a3; + sp.f1a = 0; + sp.f1e = a4; + sp.f20 = a5; + sp.f1c = 0x7FFF; + sp.f14 = t; + func_8012C51C(&sp, a0); +} + + + +extern void func_8012EC04(s32 param_1, s32 param_2, s32 *param_3); +extern void func_8012F14C(s32 a0, s32 a1, s32 a2); + +void func_80187414(s32 a0, void *a1, void *a2, s32 a3) { + s32 buf0; + s32 buf1; + s32 buf2; + s32 temp[8]; + func_8012EC04(a0, a3, temp); + func_8012F14C((s32)temp, (s32)a1, (s32)a2); +} + + + +extern s32 func_8012B6D4(s16 *a0, s16 *a1); + +// @class: branch-polarity +// @stuck: none — MATCH (32 ins), iteration 2. §3-T4: gcc-2.7.2 lays this out as +// "branch TO the then-arm, fall through to the else", so the source condition is +// `d < 0x800` (the bnez sense read off the target opcode), NOT Ghidra's inverted +// arm order. The wrong polarity also cost one instruction (match_one printed +// LENGTH-DRIFT/-1): with the arms swapped, the `sll $v0,$s0,16` of the s16 param +// lands in the branch delay slot and is SHARED by both arms; the correct polarity +// puts `addiu $v1,$zero,0x1000` there and each arm gets its own sll/sra. +// a1 is an ANSI s16 param (sign-extended at each use, once per arm) — not K&R §43. +s32 aF80187460(s32 a0, s16 a1) __asm__("func_80187460"); +s32 aF80187460(s32 a0, s16 a1) +{ + /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every + LATER function in this TU, which blocks a byte-true decl of a different type. + Declaration-only move (cookbook §103); the whole-binary byte-gate is the arbiter. */ + extern u8 D_80126B5C; + /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every + LATER function in this TU, which blocks a byte-true decl of a different type. + Declaration-only move (cookbook §103); the whole-binary byte-gate is the arbiter. */ + extern s32 *D_80126B78; + s32 d; + + d = (func_8012B6D4((s16 *)&D_80126B5C, (s16 *)(a0 + 4)) - + *(s16 *)((s32)D_80126B78 + 0x12)) & 0xFFF; + if (d < 0x800) { + return d < a1; + } else { + return (0x1000 - d) < a1; + } +} + + +s32 func_801874E0(s32 param_1, s32 param_2, s32 param_3) +{ + s32 result; + + if (func_8012BEE8(param_1) != 0) { + result = func_80132EF4(param_1, 0x22); + if (result != 0) { + *(u16 *)(result + 0x34) = 0x7FFF; + *(u16 *)(*(s32 *)(result + 0x20) + 0x2C) = 0xC006; + *(u32 *)(result + 0x14) = 0xFFFE0000; + } + return 1; + } + return 0; +} + + + +extern void (*D_801BD4D8[])(void); + +void func_80187548(void *a0) { + D_801BD4D8[*(u16 *)((s32)a0 + 0x2)](); +} + + + + +extern s32 rand(void); +extern void func_8012C1B8(void); +extern void func_8012CAE4(void*); +extern void func_8001C214(s32 a0, s32 a1); +extern void func_8012B2CC(s32 a0); +extern void func_8012B178(s32 a0, s32 a1); + +void func_80187584(s32 param_1) { + + extern u8 D_801BD4E0[]; + s32 unused[2]; /* dead 8-byte local — frame padding (cookbook idiom 6) */ + s32 obj; + s16 raw; + s32 r; + s32 sgn; + s32 v; + u8 *tbl; + s16 *p; + s32 q; + s32 w; + + obj = ((s32 (*)(void))func_8012C1B8)(); + if (obj == 0) { + ((void (*)(s32))func_8012CAE4)(param_1); + return; + } + *(s32 *)(param_1 + 0x20) = obj; + func_8001C214(obj, 0); + + raw = rand(); + r = raw; + *(u16 *)(obj + 0x2C) = *(u16 *)(obj + 0x2C) | 0x10; + v = r % 384 + 0x400; + *(s16 *)(obj + 0x1C) = v; + *(s16 *)(obj + 0x1A) = v; + *(s16 *)(obj + 0x18) = v; + sgn = -1; + if (raw & 1) { + sgn = 1; + } + *(s16 *)(obj + 0x10) = sgn * (r % 128) - 0x300; + *(s16 *)(obj + 0x12) = r % 4096; + *(s32 *)(param_1 + 0x48) = 0xC000; + *(u16 *)(param_1 + 0xA) = *(u16 *)(param_1 + 0xA) - 0x19; + func_8012B2CC(param_1); + func_8012B178(param_1, -0xC0000 - ((r % 8) << 16)); + *(s32 *)(param_1 + 0x1C) = 0x3C; + *(s16 *)(param_1 + 0xFE) = rand() & 0xF0; + *(s16 *)(param_1 + 0x100) = rand() & 0x1F0; + *(s16 *)(param_1 + 0x102) = rand() & 0x30; + tbl = &D_801BD4E0[(*(u16 *)(param_1 + 0x70) & 0xF) * 4]; + + p = (s16 *)(param_1 + 0xDC); + + q = rand() % 12; + if ((rand() & 1) == 0) { + w = -q - 0x18; + } else { + w = q - 0x18; + } + p[0] = w; + p[1] = 0; + + q = rand() % 12; + if ((rand() & 1) == 0) { + w = -q - 0x18; + } else { + w = q - 0x18; + } + p[2] = w; + + q = rand() % 12; + if ((rand() & 1) == 0) { + w = -q + 0x18; + } else { + w = q + 0x18; + } + p[4] = w; + p[5] = 0; + + q = rand() % 12; + if ((rand() & 1) == 0) { + w = -q - 0x18; + } else { + w = q - 0x18; + } + p[6] = w; + + q = rand() % 12; + if ((rand() & 1) == 0) { + w = -q - 0x18; + } else { + w = q - 0x18; + } + p[8] = w; + p[9] = 0; + + q = rand() % 12; + if ((rand() & 1) == 0) { + w = -q + 0x18; + } else { + w = q + 0x18; + } + p[10] = w; + + q = rand() % 12; + if ((rand() & 1) == 0) { + w = -q + 0x18; + } else { + w = q + 0x18; + } + p[12] = w; + p[13] = 0; + + q = rand() % 12; + if ((rand() & 1) == 0) { + w = -q + 0x18; + } else { + w = q + 0x18; + } + p[14] = w; + + *((u8 *)p + 0x20) = tbl[0]; + *((u8 *)p + 0x21) = tbl[1]; + *((u8 *)p + 0x22) = tbl[2]; + *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1; +} + + + +extern s32 func_8012CBF4(s32 a0); +extern s32 func_8012BEE8(s32 a0); +extern void func_8012C218(void *a0); /* TU-canonical (ov_SC06_018_jr_8017C24C L5455) */ +extern void func_80017274(s32 a0, s32 a1); + +void func_801879E8(s32 param_1) { + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) + *(u16 *)(param_1 + 0xFE); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + *(u16 *)(param_1 + 0x100); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) = + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14) + *(u16 *)(param_1 + 0x102); + + if (func_8012CBF4(param_1) != 0 || func_8012BEE8(param_1) != 0) { + func_8012C218((void *)param_1); + } else { + func_80017274(param_1 + 0xDC, *(s32 *)(param_1 + 0x20) + 0x34); + } +} + + + +extern void (*D_801BD4F8[])(void); + +void func_80187A8C(void *a0) { + D_801BD4F8[*(u16 *)((s32)a0 + 0x2)](); +} + + + +extern s32 rand(void); +extern void func_8012C1B8(void); /* TU-canonical (ov_SC06_018_jr_8017C24C) */ +extern void func_8012CAE4(void*); +extern void func_8001C214(s32 a0, s32 a1); +extern void func_8012B0B4(unsigned int *p, int a1, int a2); /* TU-canonical */ +extern void func_8012B2CC(s32 a0); + +void func_80187AC8(s32 param_1) { + u32 buf[2]; + s32 obj; + s32 o2; + s32 base; + s32 off; + s32 v; + s32 t; + + obj = ((s32 (*)(void))func_8012C1B8)(); + *(s32 *)(param_1 + 0x20) = obj; + if (obj == 0) { + ((void (*)(s32))func_8012CAE4)(param_1); + } else { + func_8001C214(obj, 0); + if ((*(s16 *)(param_1 + 0x70) & 0x8000) == 0) { + *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = -0x80 - (rand() % 0x300); + o2 = *(s32 *)(param_1 + 0x20); + off = rand() % 0xC0; + base = *(s16 *)(param_1 + 0x70) * 0x300 + 0x180; + if (rand() & 1) { + v = base + off; + } else { + v = base - off; + } + *(s16 *)(o2 + 0x12) = v; + func_8012B0B4(buf, *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) + 0x800, + rand() % 0x10 + 8); + t = buf[0]; + *(u16 *)(param_1 + 0x6) = *(u16 *)(param_1 + 0x6) + t; + *(u16 *)(param_1 + 0xE) = *(u16 *)(param_1 + 0xE) + (t >> 16); + *(u16 *)(param_1 + 0xA) = *(u16 *)(param_1 + 0xA) - 0x10; + func_8012B2CC(param_1); + *(s32 *)(param_1 + 0x1C) = 4; + *(u16 *)(param_1 + 0x2) = *(u16 *)(param_1 + 0x2) + 1; + } else { + *(s16 *)(param_1 + 0xDC) = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xCC); + *(s16 *)(param_1 + 0xDE) = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xCE); + *(s16 *)(param_1 + 0xE0) = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xD0); + *(s16 *)(param_1 + 0xE4) = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xD4); + *(s16 *)(param_1 + 0xE6) = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xD6); + *(s16 *)(param_1 + 0xE8) = *(u16 *)(*(s32 *)(param_1 + 0x64) + 0xD8); + *(s16 *)(param_1 + 0x2) = 2; + *(s32 *)(param_1 + 0x1C) = 8; + } + } +} + + + + +extern s32 func_8012BEE8(s32 a0); +extern void func_8012C218(void *a0); +extern s32 func_80017758(void *a0, void *a1); + +void func_80187CBC(void *a0) +{ + u8 buf[0x34]; + + if (*(u16 *)((u8 *)a0 + 0x34) == 0) { + *(s32 *)((u8 *)a0 + 0xE0) = *(s32 *)((u8 *)a0 + 0xE0) - 0x14; + if (func_8012BEE8((s32)a0) != 0) { + *(u16 *)((u8 *)a0 + 0x34) = *(u16 *)((u8 *)a0 + 0x34) + 1; + } + } else { + s32 v1 = *(s32 *)((u8 *)a0 + 0x64); + if (*(s32 *)(*(s32 *)(v1 + 0x20) + 4) < 0 || *(u16 *)v1 == 0) { + func_8012C218(a0); + return; + } + } + + *(s16 *)(buf + 0x00) = 4; + *(s16 *)(buf + 0x08) = -4; + { + s16 c = 0xC; + *(s16 *)(buf + 0x02) = 0; + *(s16 *)(buf + 0x04) = 0; + *(s16 *)(buf + 0x0A) = 0; + *(s16 *)(buf + 0x0C) = 0; + *(s16 *)(buf + 0x10) = c; + } + *(s16 *)(buf + 0x12) = 0; + { + s32 t1 = *(s32 *)((u8 *)a0 + 0xE0); + s32 t2; + *(s16 *)(buf + 0x18) = -0xC; + *(s16 *)(buf + 0x1A) = 0; + *(s16 *)(buf + 0x14) = t1; + t2 = *(s32 *)((u8 *)a0 + 0xE0); + *(s32 *)(buf + 0x30) = 0x50000000; + *(u8 *)(buf + 0x22) = 0x80; + *(u8 *)(buf + 0x21) = 0x80; + *(u8 *)(buf + 0x20) = 0x80; + *(u8 *)(buf + 0x26) = 0x80; + *(u8 *)(buf + 0x25) = 0x80; + *(u8 *)(buf + 0x24) = 0x80; + *(u8 *)(buf + 0x2A) = 0x30; + *(u8 *)(buf + 0x29) = 0x30; + *(u8 *)(buf + 0x28) = 0x30; + *(u8 *)(buf + 0x2E) = 0x30; + *(u8 *)(buf + 0x2D) = 0x30; + *(u8 *)(buf + 0x2C) = 0x30; + *(s16 *)(buf + 0x1C) = t2; + } + + func_80017758(buf, (u8 *)(*(s32 *)((u8 *)a0 + 0x20)) + 0x34); +} + + +typedef struct { s16 vx, vy, vz, pad; } SVec_80186E9C_8018BCC4_80187DF8; /* 8 bytes, align 2 -> lwl/lwr block move */ +typedef struct { s32 a; s32 b[4]; } OtBlk_8018A974_8018EB08_8018A28C_80187DF8; /* == engine_types.h OtBlk (0x14) */ +typedef struct { + u16 f0; /* 0x00 entity kind; 0x282 is the one we want */ + s16 f2; /* 0x02 state -> 9 on a hit */ + u8 p04[0x20 - 0x04]; + s32 f20; /* 0x20 collision volume A */ + u8 p24[0x58 - 0x24]; + s32 f58; /* 0x58 collision volume B */ + u8 p5C[0x70 - 0x5C]; + s16 f70; /* 0x70 sub-kind / owner tag */ + u8 p72[0x10C - 0x72]; /* stride 0x10C, 0x60 entries (0x6480) */ +} Ent_80188E10_80187DF8; +typedef struct { + SVECTOR_8016E7C8 v[4]; /* 0x00 */ + s32 f0, f1, f2, f3, f4, f5; /* 0x20..0x37 */ + u8 f6; /* 0x38 */ + u8 pad[7]; /* -> 0x40 */ +} Prim_8016E7C8_80187DF8; + +/* TU-canonical declarations (law 2) — verbatim from + * src/ov_SC06_018/ov_SC06_018_jr_80187AEC.c (L2761/2988/etc for func_8012C218, + * L1752 for func_80017758). */ +extern void func_8012C218(void *a0); +extern s32 func_80017758(void *a0, void *a1); + +/* Same-TU spelling already used at L4773 for this exact symbol (block-scoped + * extern, address-of use — matches this function's need exactly). */ + + +/* Isomorphic twin: ov_SC06_032:func_80184B08 (skeleton similarity 1.0, byte- + * identical instruction stream). Copied verbatim with only the symbol/function + * name unchanged (all callee/global symbols are shared across overlays). */ +void func_80187DF8(void *a0) +{ + extern Blk20_8018AF88 D_800AE620; + s32 c; + + if (*(u16 *)((u8 *)a0 + 0x34) == 0) { + *(u16 *)((u8 *)a0 + 0xCC) = *(u16 *)(*(s32 *)((u8 *)a0 + 0x64) + 0xCC); + *(u16 *)((u8 *)a0 + 0xCE) = *(u16 *)(*(s32 *)((u8 *)a0 + 0x64) + 0xCE); + *(u16 *)((u8 *)a0 + 0xD0) = *(u16 *)(*(s32 *)((u8 *)a0 + 0x64) + 0xD0); + *(u16 *)((u8 *)a0 + 0xD4) = *(u16 *)(*(s32 *)((u8 *)a0 + 0x64) + 0xD4); + *(u16 *)((u8 *)a0 + 0xD6) = *(u16 *)(*(s32 *)((u8 *)a0 + 0x64) + 0xD6); + *(u16 *)((u8 *)a0 + 0xD8) = *(u16 *)(*(s32 *)((u8 *)a0 + 0x64) + 0xD8); + *(u16 *)((u8 *)a0 + 0x34) += 1; + } + + *(s32 *)((u8 *)a0 + 0xFC) = 0x50000000; + + c = *(s32 *)((u8 *)a0 + 0x1C); + { + u8 v = (u8)(c * 30); + + *(u8 *)((u8 *)a0 + 0xEC) = + *(u8 *)((u8 *)a0 + 0xED) = + *(u8 *)((u8 *)a0 + 0xEE) = + *(u8 *)((u8 *)a0 + 0xF0) = + *(u8 *)((u8 *)a0 + 0xF1) = + *(u8 *)((u8 *)a0 + 0xF2) = + *(u8 *)((u8 *)a0 + 0xF4) = + *(u8 *)((u8 *)a0 + 0xF5) = + *(u8 *)((u8 *)a0 + 0xF6) = + *(u8 *)((u8 *)a0 + 0xF8) = + *(u8 *)((u8 *)a0 + 0xF9) = + *(u8 *)((u8 *)a0 + 0xFA) = v; + } + + func_80017758((u8 *)a0 + 0xCC, &D_800AE620); + + { + s32 d = *(s32 *)((u8 *)a0 + 0x1C) - 1; + + *(s32 *)((u8 *)a0 + 0x1C) = d; + if (d == 0) { + func_8012C218(a0); + } + } +} + + +extern s32 D_80126B58; +extern void func_8012EFB8(s32 a0); +extern s32 func_800132BC(void *a0, void *a1); +extern void func_8002D4C8(s32 a0, s32 a1); + +s32 func_80187EF4(s32 arg0, u16 arg1) { + s16 sp10[3]; + s16 sp18[3]; + s16 sp20[3]; + s16 sp28[3]; + s32 x; + s32 var; + s32 q; + s16 b; + s32 base; + + base = (s32)&D_80126B58; + sp10[0] = *(u16 *)(arg0 + 6); + sp10[1] = *(u16 *)(arg0 + 0xA); + sp10[2] = *(u16 *)(arg0 + 0xE); + ((void (*)(s32, s32))func_8012EFB8)((s32)sp10, (s32)sp18); + x = 0x7F; + q = sp18[0]; + b = q / 25 + 7; + sp18[2] = 0; + if (b < 0) { + b = 0; + } else if (b >= 0x10) { + b = 0xF; + } + sp20[0] = *(u16 *)(base + 6); + sp20[1] = *(u16 *)(base + 0xA); + sp20[2] = *(u16 *)(base + 0xE); + ((void (*)(s32, s32))func_8012EFB8)((s32)sp20, (s32)sp28); + sp28[2] = 0; + if ((var = func_800132BC(sp18, sp28) - 0x400) > 0) { + if (var < 0x6E40) { + x -= var * 95 / 28224; + } else { + x = 0x2F; + } + } + func_8002D4C8(arg1, (u16)(x | ((b << 8) | 0x3000))); + return 1; +} + + + +extern void (*D_801BD504[])(void); + +void func_80188060(void *a0) { + D_801BD504[*(u16 *)((s32)a0 + 0x2)](); +} + + + +extern void func_80128EA8(s32 a0, s32 a1, s32 a2); + +void func_8018809C(s32 param_1) { + + extern u8 D_800D387C[]; + extern u8 D_800D3888[]; + s32 t; + + *(u32 *)(*(s32 *)(param_1 + 0x20) + 0x20) = (u32)&D_800D387C; + + *(u32 *)(*(s32 *)(param_1 + 0x20) + 4) |= 0x50000000; + + *(u8 *)(*(s32 *)(param_1 + 0x20) + 0x27) = 0x9c; + + t = *(s32 *)(param_1 + 0x20); + *(u16 *)(t + 0x1a) = 0x2000; + *(u16 *)(t + 0x18) = 0x2000; + + *(u8 *)(*(s32 *)(param_1 + 0x20) + 0x24) = 0xff; + *(u8 *)(*(s32 *)(param_1 + 0x20) + 0x25) = 0; + *(u8 *)(*(s32 *)(param_1 + 0x20) + 0x26) = 0; + + func_80128EA8(*(s32 *)(param_1 + 0x20), param_1 + 0x24, (s32)&D_800D3888); + + *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1; +} + + + +extern void func_8012931C(s32 a0); +extern s32 func_80128ED8(s32 param_1, s32 *param_2); +extern void func_801292C8(s32 a0); + +void func_8018814C(s32 param_1) { + s32 q; + u8 a; + u8 b; + u16 h; + + q = *(s32 *)(param_1 + 0x20); + + a = *(u8 *)(q + 0x24) - 0x20; + *(u8 *)(q + 0x24) = a; + if (a < 0x80) { + *(u8 *)(q + 0x24) = 0x80; + } + + b = *(u8 *)(q + 0x25) + 0x20; + *(u8 *)(q + 0x25) = b; + if (b > 0x80) { + *(u8 *)(q + 0x25) = 0x80; + } + + h = *(u16 *)(q + 0x1A) + 0x400; + *(u8 *)(q + 0x26) = *(u8 *)(q + 0x25); + *(u16 *)(q + 0x1A) = h; + *(u16 *)(q + 0x18) = h; + + func_8012931C(param_1); + + if (func_80128ED8((void *)q, (void *)(param_1 + 0x24)) != 0) { + func_801292C8(param_1); + } +} + + + +extern s32 D_801E20F8; +extern s32 func_8012C588(s32 a0, s32 a1); + +s32 func_80188204(s32 a0, s32 a1) { + D_801E20F8 = a1; + return func_8012C588(0x85, a0); +} + + +extern u8 D_801152A8[]; +extern s32 D_801E20F8; +extern s32 func_80017DC4(void *a0, void *a1); +extern void func_80017E68(void *a0, void *a1); +extern void func_800D20C0(void *a0, void *a1, s32 a2); +extern void func_800D23D0(void *a0); +extern void func_8012A828(s32 a0, void *a1); +extern void func_8012C218(void *a0); +extern void func_8012F14C(s32 a0, s32 a1, s32 a2); +extern s32 func_80134510(s32 arg); + +// @class: regalloc-order +// @stuck: none — MATCH (145/145 ins, match_one confirmed) + + + + +s32 func_80188234(s32 param_1) { + + extern M2C_UNK D_8018D644; + extern s32 func_8012C354(s32 a0, s32 a1); + extern void RotMatrixZ(s32, void *); + extern void MulMatrix0(s32, void *, s32); + extern s32 D_801D530C; + extern char * D_801D5340; + extern char D_801E20D8[]; + + S8_80184F08 s60; + SVECTOR_80184F08 sStack_58; + S8_80184F08 s50; + int auStack_48[8]; + s32 iVar5, iVar8; + char *puVar2, *puVar4; + u16 uVar3; + + if (((s32 (*)(s32, void *))func_8012C354)(param_1, &D_801D530C) == 0) { + ((void (*)(s32))func_8012C218)(param_1); + } + ((void(*)(s32, void *))func_8012A828)(param_1, &(*(s32 *)&D_8018D644)); + iVar5 = *(s32 *)(param_1 + 0x20); + *(s16 *)(param_1 + 0x70) = 0x80; + *(s32 *)(iVar5 + 4) |= 0x50000040; + *(u16 *)(iVar5 + 0x2c) |= 1; + iVar8 = *(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x34; + ((void (*)(s32, s32, void *))func_8012F14C)(iVar8, D_801E20F8, &s60); + s50 = s60; + sStack_58.vz = 0x1800; + sStack_58.vy = 0x1800; + sStack_58.vx = 0x1800; + ((void (*)(void *, void *))func_80017DC4)(&sStack_58, auStack_48); + RotMatrixZ(rand() & 0xfff, auStack_48); + MulMatrix0(iVar8, auStack_48, iVar5 + 0x34); + ((void (*)(void *, s32))func_80017E68)(&s50, iVar5 + 0x34); + + /* pool-alloc: gcc routes the loaded pointer through a caller-saved reg ($v0) + before the callee-saved home ($s1) — pin it to reproduce the extra move. */ + { + register char *tmp __asm__("$2"); // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus9) + tmp = D_801D5340; + puVar2 = tmp; + } + puVar4 = puVar2 + 0x20; + D_801D5340 = puVar4; + *(char **)(param_1 + 0xcc) = puVar2; + if (D_801E20D8 < puVar4) { + D_801D5340 = D_801E20D8 - 0x120; + } + func_800D20C0(&s60, &sStack_58, 7); + func_800D23D0(&sStack_58); + ((void(*)(void *, void *))RotMatrixYXZ)(&sStack_58, puVar2); + ((void (*)(void *, s32))func_80017E68)(&s60, (s32)puVar2); + + uVar3 = *(u16 *)((char *)&s50 + 2); + if (((s32 (*)(void *))func_80134510)(&s50) != 0 && + (s32)(s16)uVar3 - (s32)*(s16 *)((char *)&s50 + 2) < 0x80) { + *(s16 *)((char *)&s50 + 2) = *(s16 *)((char *)&s50 + 2) - 4; + { + register char *tmp __asm__("$3"); // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9) + tmp = D_801D5340; + puVar2 = tmp; + } + puVar4 = puVar2 + 0x20; + D_801D5340 = puVar4; + *(char **)(param_1 + 0xd0) = puVar2; + if (D_801E20D8 < puVar4) { + D_801D5340 = D_801E20D8 - 0x120; + } + func_800D23D0(&(*(s32 *)&D_801152A8)); + ((void(*)(void *, void *))RotMatrixYXZ)(&(*(s32 *)&D_801152A8), puVar2); + ((void (*)(void *, s32))func_80017E68)(&s50, (s32)puVar2); + } + *(s16 *)(param_1 + 2) = *(s16 *)(param_1 + 2) + 1; +} + + +extern s32 func_80017758(void *a0, void *a1); +extern void func_8012C218(void *a0); + + +// @class: regalloc-order +// @stuck: none — MATCH (168 ins). Keys: (1) pin param->$s1 via `register int self __asm__("$17")=param_1` +// (natural alloc put the short loop-counter in $s1); (2) block2's guarded dest via a test-temp +// `td=load; if(td){dest=td; ...}` forces the range-split `lw $a1; addu $s3,$a1,$0` the target has; +// (3) counter is `short i` do-while (keeps the `addu $s2,$v0,$0` raw-copy + sll16/sra16 compare); +// (4) gcc-2.7.2 loads s8/s16 via lbu/lhu+shift-extend (not lb/lh) so `signed char *p; *(s16*)buf=*p++` +// emits lbu;sll24;sra24;sh; (5) else-branch zero-byte asm barrier forces `addu $a0,$s1,$0` (else gcc +// reuses the still-live incoming $a0 with a nop delay slot). + +s32 func_80188478(s32 param_1) { + + extern signed char D_801D52F8[]; + int self = ((int)param_1); + int iVar6; + int iVar1; + unsigned char buf[0x34]; + signed char *p; + short i; + int dest; + int td; + unsigned short t; + + do { iVar1 = *(int *)(self + 0x1c); } while (0); + iVar6 = *(int *)(self + 0x20); + *(int *)(self + 0x1c) = iVar1 + 1; + if (iVar1 < 2) { + p = D_801D52F8; + i = 0; + dest = *(int *)(self + 0xcc); + t = *(unsigned short *)(self + 0x70); + *(short *)(buf + 0x0c) = 0; + *(short *)(buf + 0x0a) = 0; + *(short *)(buf + 0x08) = 0; + *(short *)(buf + 0x1c) = 0; + *(short *)(buf + 0x14) = 0; + *(short *)(buf + 0x04) = 0; + buf[0x22] = 0; + buf[0x21] = 0; + buf[0x20] = 0; + buf[0x2a] = 0; + buf[0x29] = 0; + buf[0x28] = 0; + buf[0x2e] = 0; + buf[0x2d] = 0; + buf[0x2c] = 0; + *(int *)(buf + 0x30) = 0x50000000; + buf[0x25] = t; + buf[0x26] = t; + buf[0x24] = t; + do { + *(short *)(buf + 0x00) = *p++; + *(short *)(buf + 0x02) = *p++; + *(short *)(buf + 0x10) = *p++; + *(short *)(buf + 0x12) = *p++; + *(short *)(buf + 0x18) = *p++; + *(short *)(buf + 0x1a) = *p--; + func_80017758(buf, (void *)dest); + i++; + } while (i < 4); + + td = *(int *)(self + 0xd0); + if (td != 0) { + dest = td; + p = D_801D52F8; + i = 0; + t = *(unsigned short *)(self + 0x70); + *(short *)(buf + 0x0c) = 0; + *(short *)(buf + 0x0a) = 0; + *(short *)(buf + 0x08) = 0; + *(short *)(buf + 0x1c) = 0; + *(short *)(buf + 0x14) = 0; + *(short *)(buf + 0x04) = 0; + buf[0x22] = 0; + buf[0x21] = 0; + buf[0x20] = 0; + buf[0x2a] = 0; + buf[0x29] = 0; + buf[0x28] = 0; + buf[0x2e] = 0; + buf[0x2d] = 0; + buf[0x2c] = 0; + *(int *)(buf + 0x30) = 0x50000000; + buf[0x25] = t; + buf[0x26] = t; + buf[0x24] = t; + do { + *(short *)(buf + 0x00) = *p++; + *(short *)(buf + 0x02) = *p++; + *(short *)(buf + 0x10) = *p++; + *(short *)(buf + 0x12) = *p++; + *(short *)(buf + 0x18) = *p++; + *(short *)(buf + 0x1a) = *p--; + func_80017758(buf, (void *)dest); + i++; + } while (i < 4); + } + do { *(short *)(self + 0x70) = *(short *)(self + 0x70) >> 1; } while (0); + *(unsigned short *)(iVar6 + 0x2c) |= 1; + } else { + func_8012C218((void *)self); + } +} + + + +extern void (*D_801D5344[])(void); + +void func_80188718(void *a0) { + D_801D5344[*(u16 *)((s32)a0 + 0x2)](); +} + + + + +// @class: schedule +// @stuck: none — MATCH (132 ins, match_one). Levers: (1) block2 statement order — compute sv1.vz (with the *(p+0xe) load) right after the 2nd call so gcc hoists that load into $v1, forcing the sv2.vx=sv1.vx copy through $a3, which globally pushes every `func*param>>12` product from $a3 to $t0; (2) sv2 store order vx-before-vy; (3) SHARED return-0 join via gotos placed BEFORE the copy block (ret0: before docopy:) — this blocks gcc's conditional-jump-over-jump inversion + return-threading, so the copy block falls through to the epilogue with v0=1 preset in the beqz delay slot (drops the extra `li v0,1`). + + +extern int func_8004787C(int); +extern int func_80047948(int); +extern s32 func_80133784(s32, void*, s32); + +int func_80188754(int param_1, short param_2) +{ + int iVar1; + unsigned int uVar2; + int iVar3; + SVECTOR sv1; + SVECTOR sv2; + + if (*(int *)(param_1 + 0xdc) != 0) goto ret0; + sv1.vx = *(short *)(param_1 + 6); + sv1.vy = *(short *)(param_1 + 0xa) + -0x20; + sv1.vz = *(short *)(param_1 + 0xe); + iVar1 = func_8004787C(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + iVar3 = (int)param_2; + sv2.vy = sv1.vy; + sv2.vx = sv1.vx - (short)(iVar1 * iVar3 >> 0xc); + iVar1 = func_80047948(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + sv2.vz = sv1.vz - (short)(iVar1 * iVar3 >> 0xc); + uVar2 = ((int (*)(int, SVECTOR *, SVECTOR *))func_80133784)(1, &sv1, &sv2); + if ((uVar2 & 0x8000) != 0) { + iVar1 = func_8004787C(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + *(short *)(param_1 + 6) = sv2.vx + (short)(iVar1 * iVar3 >> 0xc); + iVar1 = func_80047948(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + *(short *)(param_1 + 0xe) = sv2.vz + (short)(iVar1 * iVar3 >> 0xc); + return 1; + } + iVar1 = func_8004787C(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + sv1.vx = *(short *)(param_1 + 6) - (short)(iVar1 * iVar3 >> 0xc); + sv1.vy = *(short *)(param_1 + 0xa) + -0x10; + iVar1 = func_80047948(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + sv1.vz = *(short *)(param_1 + 0xe) - (short)(iVar1 * iVar3 >> 0xc); + sv2.vx = sv1.vx; + sv2.vy = sv1.vy + 0x20; + sv2.vz = sv1.vz; + uVar2 = ((int (*)(int, SVECTOR *, SVECTOR *))func_80133784)(1, &sv1, &sv2); + if ((uVar2 & 0x6000) == 0) goto docopy; +ret0: + return 0; +docopy: + *(int *)(param_1 + 4) = *(int *)(param_1 + 0x38); + *(int *)(param_1 + 8) = *(int *)(param_1 + 0x3c); + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0x40); + return 1; +} + + + + +/* func_80188964 — ov_SC06_008 / ov_SC06_008_jr_8017C294 + * + * Two-arm actor tick keyed on the s16 countdown at actor+0xFC: + * arm A (counter == 0, the FALL-THROUGH / longer block): three func_8012C658 + * spawns with offset pokes, a sound cue, two child-actor state pokes, an + * 8-iteration 0x281 particle burst, then the RTP positional-sound block + * (the byte-proven RTP_SND shape from ov_SC03_099_jr_8017BEBC.c:5406). + * arm B (counter != 0): a func_8012913C(0x23) spawn scattered around the + * actor, VectorNormalSS toward D_801151D4->{0x5C,0x60,0x64}, sound 0xAF8. + * + * Declarations copied VERBATIM from the TU (one-pass grep, D2): + * D_801151D4 src/ov_SC06_008/ov_SC06_008_jr_8017C294.c:323 + * rand :956 + * VectorNormalSS :1849 + * func_8012C658 :2523 + * func_8012C588 :3767 + * func_8012C218 :3782 + * func_8002D4C8 :59 + * func_8004914C :2645 + * func_800491AC :2646 + * func_8012913C :4356 (non-prototype form, BELOW the splice point) + * func_8002AC00 :5447 (block-scope extern only) + * RotTransPers / D_800AF648 / func_8002A04C are not in this TU -> fleet-dominant forms. + */ + +extern s32 rand(void); +extern s32 VectorNormalSS(void *a0, void *a1); +extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2); +extern s32 func_8012C588(s32 a0, s32 a1); +extern void func_8012C218(void *a0); +extern void func_8002D4C8(s32 a0, s32 a1); +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern void func_8002A04C(s32 a0); +extern void func_8002AC00(s32 a0); +extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); +extern u8 *func_8012913C(); + +void func_80188964(s32 a0) +{ + + extern s32 D_801151D4; + extern u8 D_800AF648; + + /* L5: slot offsets are exact only through ONE struct — plain array locals + get 8-byte-rounded slots and pushed z/flag to 0x28/0x2C (measured). */ + struct { + u16 nv[4]; /* sp+0x10 */ + s16 rv[4]; /* sp+0x18 */ + u16 sxy[2]; /* sp+0x20 */ + s32 z; /* sp+0x24 */ + s32 flag; /* sp+0x28 */ + } L; + + s32 g; + s32 s0; + s32 i; + + g = D_801151D4; + + if (*(s16 *)(a0 + 0xFC) == 0) { + s0 = func_8012C658(0x33, 3, a0); + if (s0 != 0) { + *(u16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) - 0x20; + *(u16 *)(s0 + 0x12) = *(u16 *)(s0 + 0x12) - 8; + *(u16 *)(s0 + 0x1A) = *(u16 *)(s0 + 0x1A) - 5; + } + s0 = func_8012C658(0x33, 3, a0); + if (s0 != 0) { + *(u16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) - 0x20; + *(u16 *)(s0 + 0x12) = *(u16 *)(s0 + 0x12) - 8; + *(u16 *)(s0 + 0x1A) = *(u16 *)(s0 + 0x1A) + 5; + } + s0 = func_8012C658(0x32, 2, a0); + if (s0 != 0) { + *(u16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) - 0x20; + *(u16 *)(s0 + 0x12) = *(u16 *)(s0 + 0x12) + 8; + } + func_8002AC00(0x22); + + s0 = *(s32 *)(a0 + 0xCC); + *(s16 *)(s0 + 0x2) = 2; + *(s16 *)(s0 + 0xFC) = 1; + s0 = *(s32 *)(a0 + 0xD0); + *(s16 *)(s0 + 0x2) = 2; + *(s16 *)(s0 + 0xFC) = 1; + + for (i = 0; i < 8; i++) { + s0 = func_8012C588(0x281, a0); + if (s0 != 0) { + *(s32 *)(s0 + 0x1C) = 2; + *(u16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) - 0x30; + *(s16 *)(s0 + 0x12) = (rand() & 0x1F) - 0x10; + *(s16 *)(s0 + 0x16) = -((rand() & 0xF) + 0x10); + *(s16 *)(s0 + 0x1A) = (rand() & 0x1F) - 0x10; + } + } + + L.rv[0] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x48); + L.rv[1] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x4C); + L.rv[2] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x50); + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_8004914C(r4); } // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + { void *r4; r4 = &D_800AF648; func_800491AC(r4); } + RotTransPers((s32)L.rv, (s32)L.sxy, &L.z, &L.flag); + if (L.flag >= 0 && (u32)((L.sxy[0] + 0xEF) & 0xFFFF) < 0x1DF + && (u32)((L.sxy[1] + 0xB3) & 0xFFFF) < 0x167) { + s32 x = (s16)L.sxy[0]; + s32 ax; + + ax = x; + if (x < 0) { + ax = -x; + } + ax = ((0xF0 - ax) * 0x7F) / 0xF0; + x = (x + 0xF0) / 0x1E; + if (x == 0x10) { + x = 0xF; + } + x = x << 8; + { + s32 flg = 0x3000; + func_8002D4C8(0x961, ((ax | flg) | x) & 0xFFFF); + } + } + func_8002A04C(a0); + func_8012C218((void *)a0); + } else { + s0 = (s32)func_8012913C(0x23); + if (s0 != 0) { + *(s16 *)(s0 + 0x6) = *(u16 *)(a0 + 0x6) + (rand() & 0x7F) - 0x40; + *(s16 *)(s0 + 0xA) = *(u16 *)(a0 + 0xA) + (rand() & 0x7F) - 0xE0; + { + s32 r = rand(); + s32 t = *(u16 *)(a0 + 0xE); + *(s16 *)(s0 + 0x34) = 0x1800; + *(s32 *)(s0 + 0x18) = 0; + *(s32 *)(s0 + 0x14) = 0; + *(s32 *)(s0 + 0x10) = 0; + *(s16 *)(s0 + 0xE) = t + (r & 0x7F) - 0x40; + } + L.nv[0] = *(s32 *)(g + 0x5C) - *(u16 *)(s0 + 0x6); + L.nv[1] = *(s32 *)(g + 0x60) - *(u16 *)(s0 + 0xA); + L.nv[2] = *(s32 *)(g + 0x64) - *(u16 *)(s0 + 0xE); + VectorNormalSS(L.nv, L.nv); + *(s16 *)(s0 + 0x6) = *(u16 *)(s0 + 0x6) + ((s16)L.nv[0] >> 6); + *(s16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) + ((s16)L.nv[1] >> 6); + *(s16 *)(s0 + 0xE) = *(u16 *)(s0 + 0xE) + ((s16)L.nv[2] >> 6); + *(s16 *)(s0 + 0x34) = 0x3000; + func_8002D4C8(0xAF8, 0); + } + *(u16 *)(a0 + 0xFC) = *(u16 *)(a0 + 0xFC) - 1; + } +} + + + + +// TARGET: func_80188D68 (ov_SC06_008, TU ov_SC06_008_jr_8017C294.c, 93 ins) +// +// Template: func_801821F8 in this SAME TU (src/ov_SC06_008/ov_SC06_008_jr_8017C294.c, +// around line 5283) is an already-MATCHED sibling (126 ins) with a documented byte-exact +// idiom set (its comment, verbatim): +// @class: plumbing +// @stuck: none — MATCH (126 ins). Keys: (1) cVar1 as `int` (not unsigned char) so the +// lbu-loaded byte stays full-width and gcc omits the per-compare `andi 0xff`; (2) uninitialized +// `int unaff_s1` -> $s1 (live-from-entry across func_8002D4C8); (3) func_8016AA50 takes TWO args +// (param_1, unaff_s1) — a1=unaff_s1 arg-setup is reused by the preceding subtraction and a0=s0 +// hoists into the branch delay slot; (4) 0x76 read UNSIGNED (lhu) in the subtract, SIGNED (lh) in +// the `< 1` test. +// +// func_80188D68 is the SAME body with the leading "if (*(short*)(param_1+0xfc)==0) {...}" block +// (the 0x64-indirected 3x int-copy + 3x u16-copy prologue) removed, and the "already fired" gate +// field is 0xe2 instead of 0x102. Confirmed against the target .s: no reference anywhere to 0xfc, +// 0x64, or 0x102/0x20 offsets; the gate compare is `lh $v1, 0xE2($s0)` / `sh $v1(=0xA), 0xE2($s0)`. + +extern void func_8002D4C8(int, int); +extern void func_8016AA50(int, int); +extern s32 func_8016B428(s32); +extern void func_80019064(void *); +extern void func_8002A520(int); +extern void func_8002A790(int); +extern void func_80131E00(int, int); + +void func_80188D68(int param_1) +{ + extern unsigned char D_801D5A38[]; + int cVar1; + int unaff_s1; + + cVar1 = *(unsigned char *)(param_1 + 0x5e); + *(char *)(param_1 + 0xc1) = 0; + *(short *)(param_1 + 0x5e) = 0; + *(unsigned short *)(param_1 + 0x5c) = *(unsigned short *)(param_1 + 0x5c) & 0xfffe; + if (*(short *)(param_1 + 0xe2) == 0) { + *(short *)(param_1 + 0xe2) = 10; + *(unsigned short *)(param_1 + 0x5c) = *(unsigned short *)(param_1 + 0x5c) | 0x4000; + func_8002D4C8(0x9b7, 0); + if (*(short *)(param_1 + 0x60) != 0) { + if (cVar1 == 0x1d) { + *(short *)(param_1 + 0x82) = 0; + *(short *)(param_1 + 0x7c) = *(unsigned short *)(param_1 + 6); + *(short *)(param_1 + 0x7e) = *(unsigned short *)(param_1 + 0xa); + *(short *)(param_1 + 0x80) = *(unsigned short *)(param_1 + 0xe); + } + if (*(int *)(param_1 + 0x78) != 0) { + unaff_s1 = (int)*(short *)(param_1 + 0x60) * + (int)*(short *)(*(int *)(param_1 + 0x78) + 0x30) >> 0xc; + if (unaff_s1 < 1) { + unaff_s1 = 1; + } + } + *(unsigned short *)(param_1 + 0x76) = + *(unsigned short *)(param_1 + 0x76) - unaff_s1; + func_8016AA50(param_1, unaff_s1); + if ((*(unsigned short *)(param_1 + 0x82) & 1) != 0) { + ((void (*)(int))func_8016B428)(param_1); + func_80019064(D_801D5A38); + } + } + if (cVar1 != 0x1d) { + if (*(unsigned char *)(param_1 + 0xc8) != 0) { + func_8002A520(param_1); + } + if (*(unsigned char *)(param_1 + 0xc9) != 0) { + func_8002A790(param_1); + } + } + if (*(short *)(param_1 + 0x76) < 1) { + *(short *)(param_1 + 0x5c) = 0; + func_80131E00(param_1, 6); + } + } + return; +} + + + +// @class: schedule +// @stuck: none — MATCH; success-block placed last via `goto big` (bnez forward into epilogue), single cae4 merge kept + +extern int func_8012C354(); +extern void func_800599B8(); +extern void func_8001C214(); +extern void func_80143970(); +extern void func_8012B030(); +extern void func_8012A828(); +extern void func_8012B23C(); +extern int func_8012C658(); +extern void func_8012C218(); +extern void func_8012CAE4(); + + +void func_80188EDC(int param_1) { + + extern u8 D_801D5A58[]; + extern u8 D_801D599C[]; + extern u8 D_801D595C[]; + extern u8 D_801D59A4[]; + extern u8 D_801D597C[]; + extern u8 D_801D9CC4[]; + extern u8 D_801DCF74[]; + extern u8 D_801D5A98[]; + extern u8 D_801DCDDC[]; + extern u8 D_801DCE64[]; + extern u8 D_801DCEEC[]; + int iVar1; + + iVar1 = func_8012C354(param_1, D_801D5A58); + if (iVar1 != 0) { + if (*(short *)(param_1 + 0x70) != 0) { + func_800599B8(D_801D599C, D_801D595C); + func_800599B8(D_801D59A4, D_801D597C); + func_8001C214(*(int *)(param_1 + 0x20), D_801D9CC4); + } + *(u8 *)(param_1 + 0xc0) = 1; + *(int *)(param_1 + 0xb4) = 0xffffdfde; + func_80143970(param_1); + func_8012B030(param_1); + *(short *)(param_1 + 0xae) = 0x2100; + func_8012A828(param_1, D_801DCF74); + *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1; + func_8012B23C(param_1); + *(u32 *)(param_1 + 0xc4) = *(u32 *)(param_1 + 0xc4) | 2; + iVar1 = func_8012C658(0x26f, (int)*(short *)(param_1 + 0x70), param_1); + if (iVar1 != 0) { + *(int *)(param_1 + 0xcc) = iVar1; + iVar1 = func_8012C658(0x270, (int)*(short *)(param_1 + 0x70), param_1); + if (iVar1 != 0) goto big; + func_8012C218(*(int *)(param_1 + 0xcc)); + } + func_8012CAE4(param_1); + } + return; +big: + *(int *)(param_1 + 0xd0) = iVar1; + *(u32 *)(param_1 + 0xbc) = (u32)D_801D5A98; + *(u16 *)(*(int *)(param_1 + 0x20) + 0x2c) = + *(u16 *)(*(int *)(param_1 + 0x20) + 0x2c) | 0x10; + *(short *)(*(int *)(param_1 + 0x20) + 0x18) = 0x2400; + *(short *)(*(int *)(param_1 + 0x20) + 0x1a) = 0x2400; + *(short *)(*(int *)(param_1 + 0x20) + 0x1c) = 0x2400; + *(u16 *)(param_1 + 2) = 8; + func_8012A828(param_1, D_801DCDDC); + func_8012A828(*(int *)(param_1 + 0xcc), D_801DCE64); + func_8012A828(*(int *)(param_1 + 0xd0), D_801DCEEC); + return; +} + + + +/* func_8018908C — ov_SC06_008 / ov_SC06_008_jr_8017C294. MATCH 163/163. + * Family of 7 (ov_SC06_008/010/018/022/024/032/033, all 163 ins, all still in + * nonmatchings) — §136e applies: no twin existed, so this is derived from the .s. + * The byte-proven accumulate head (b744 nested inside b608, then two RE-LOADS of + * *(s32*)(a0+0x20)) is copied verbatim from src/ov_SC03_099/..._jr_8017BEBC.c:5424. + * + * Four levers, each measured against match_one: + * + * 1. NO frame padding. args_size already fills sp+0x00..0x1F, so the four saved + * regs land at 0x20..0x2F and the frame is 0x30 with ZERO locals. A 16-byte + * dead aggregate (idiom 6, added on the first draft from a mis-derived + * args_size=0x10) made it 0x40 — idiom 6 only applies when the reg-save area + * does NOT start at args_size. + * + * 2. BRANCH POLARITY / BLOCK LAYOUT (§3-T4, T7). `if (C) goto X;` followed by a + * `break` is REWRITTEN by jump.c's jump-around-jump inversion into + * `if (!C) goto break_target;` — which is the wrong polarity here. The target + * wants the true arm to FALL THROUGH. Two rewrites, both worth +0 instructions + * but different bytes: + * case 1: `if (A||B) goto st2; break;` -> `if (!A && !B) break; goto st2;` + * (TRUTH_ANDIF gives reversed branches to `next`, and the trailing + * `j st2` is the fall-through — exactly `beqz L600 / j L5E0`.) + * case 3: same shape, plus the range test written as the POSITIVE + * `if (r >= -0xFF && r <= 0xFF) break;` so fold_range_test's + * `sltiu (r+0xFF),0x1FF` branches on TRUE to the switch end and case 3 + * falls through into st2 (saves the `j`+`nop`, 165 -> 163 ins). + * Case 0 keeps the plain `if (A||B) {..} else {..}` — there jump.c's inversion + * IS what the target has. + * + * 3. THE SHARED STORE BLOCK. L801815F8/L801815FC (`li v0,1` / `sh v0,0x34`) sit + * AFTER st2 in the target, so they are NOT inline `else` arms (cross-jumping + * keeps the LAST copy, which would put them BEFORE st2). They are explicit + * trailing labels inside the switch with an `ns` join variable; case 2 enters at + * `setstate` with ns=3, cases 0 and 3 enter at `set1`. + * + * 4. REGALLOC-PERM -> the $16 pin (see below). + */ + +extern s32 rand(void); +extern void func_8012B1B4(s32 a0, s32 a1); +extern void func_8012CBCC(s32 a0); +extern void func_8012BE98(s32 a0, u16 *a1); +extern s32 func_8012B744(void *a0, void *a1); +extern s32 func_8012B608(s32 a0, s32 a1, s32 a2); +extern void func_8012BE54(s32 a0); +extern int func_80188754(int param_1, short param_2); + +void func_8018908C(s32 a0) { + + extern u8 D_801D5AB8[]; + + /* §137/K3+K5: unpinned, the a0-copy allocno (R=37/L=137, pri 13503) is + * ranked first and first-fits $s0, pushing `tbl` to $s1 — a clean 2-reg + * perm no source reordering can flip (pri(tbl) = 394). Pinning `tbl` to + * $16 makes $s0 "already dirty" in find_reg pass 0: the a0 copy conflicts + * with it and opens $s1, and case 3's `d` (which does NOT conflict with + * `tbl`) grabs $s0 in pass 0 — exactly the target's assignment. */ + register s32 tbl __asm__("$16"); // !FAKE: pin $16 — NEEDED DIFFERS (P36 rung B tus9) + s32 ns; + + tbl = (s32)D_801D5AB8; + func_8012B1B4(a0, tbl); + func_8012CBCC(a0); + + switch (*(u16 *)(a0 + 0x34)) { + case 0: + if (func_80188754(a0, 0x48) != 0 || + ((s32(*)(s32, u16 *))func_8012BE98)(a0, (u16 *)(a0 + 0x88)) > + 0x3FFFF) { + s32 r = func_8012B608( + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12), + func_8012B744((void *)(a0 + 4), (void *)(a0 + 0x88)), 8); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + r; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) & 0xFFF; + func_8012B1B4(a0, tbl); + } else { + goto set1; + } + break; + + case 1: + if (func_80188754(a0, 0x48) == 0 && + ((s32(*)(s32, u16 *))func_8012BE98)(a0, (u16 *)(a0 + 0x88)) <= + 0x3FFFF) { + break; + } + goto st2; + + case 2: { + s32 r = func_8012B608( + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12), + func_8012B744((void *)(a0 + 4), (void *)(a0 + 0x88)), 0x10); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + r; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) & 0xFFF; + } + func_80188754(a0, 0x48); + { + s16 c = *(s16 *)(a0 + 0x102); + if (c == 0) { + ns = 3; + goto setstate; + } + *(s16 *)(a0 + 0x102) = c - 1; + } + break; + + case 3: { + void *p88 = (void *)(a0 + 0x88); + s32 d = ((s32(*)(s32, u16 *))func_8012BE98)(a0, (u16 *)p88); + if (func_80188754(a0, 0x48) == 0) { + if (d > 0x40000) { + s32 r = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12), + func_8012B744((void *)(a0 + 4), p88), 1); + if (r >= -0xFF && r <= 0xFF) { + break; + } + } else { + goto set1; + } + } + } + /* fall through into st2 */ + st2: + *(u16 *)(a0 + 0x34) = 2; + *(u16 *)(a0 + 0x102) = (rand() & 7) + 8; + break; + + set1: + ns = 1; + setstate: + *(u16 *)(a0 + 0x34) = ns; + break; + } + + { + s16 t = *(s16 *)(a0 + 0x100); + if (t != 0) { + *(s16 *)(a0 + 0x100) = t - 1; + } else if (((s32(*)(s32))func_8012BE54)(a0) <= 0x24000) { + *(s16 *)(a0 + 0x2) = 5; + *(s16 *)(a0 + 0x100) = 0x3C; + } + } +} + + +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 func_8004787C(s32 a0); +extern s32 func_80047948(s32 a0); +extern void func_8004914C(); +extern void func_800491AC(); +extern u8 *func_8012913C(s32 a0); +extern void func_8012A828(s32 a0, void * a1); +#define RTP_SND(sndid) \ + L.v[0] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x48); \ + L.v[1] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x4C); \ + L.v[2] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x50); \ + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_8004914C(r4); } \ + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_800491AC(r4); } \ + RotTransPers((s32)L.v, (s32)L.sxy, &L.z, &L.flag); \ + if (L.flag >= 0 && (u32)((L.sxy[0] + 0xEF) & 0xFFFF) < 0x1DF \ + && (u32)((L.sxy[1] + 0xB3) & 0xFFFF) < 0x167) { \ + s32 x = (s16)L.sxy[0]; \ + s32 ax; \ + ax = x; \ + if (x < 0) { \ + ax = -x; \ + } \ + ax = ((0xF0 - ax) * 0x7F) / 0xF0; \ + __asm__("" : "=r"(ax) : "0"(ax)); \ + x = (x + 0xF0) / 0x1E; \ + if (x == 0x10) { \ + x = 0xF; \ + } \ + x = x << 8; \ + { \ + s32 flg = 0x3000; \ + func_8002D4C8(sndid, ((ax | flg) | x) & 0xFFFF); \ + } \ + } + +void func_80189318(s32 a0) { + + extern u8 D_800AF648; + extern s32 D_801D591C[]; + extern u8 D_801DCDDC[]; + extern u8 D_801DCE64[]; + extern u8 D_801DCEEC[]; + struct { + s16 pad0[4]; /* sp+0x10 — dead, but sizes the frame (idiom 6) */ + s16 v[3]; /* sp+0x18 */ + s16 pad1; /* sp+0x1E */ + u16 sxy[2]; /* sp+0x20 */ + s32 z; /* sp+0x24 */ + s32 flag; /* sp+0x28 */ + } L; + s32 t; + s32 ang; + s32 idx; + s32 m; + s32 c; + s32 p; + + if (*(s16 *)(a0 + 0x98) == 0) { + s32 spr = (s32)func_8012913C(0x7F); + if (spr != 0) { + m = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + + (func_8004787C(*(s16 *)(a0 + 0x104)) >> 3); + *(s16 *)(spr + 0x6) = *(u16 *)(a0 + 0x6) - (func_8004787C(m) * 0x6C) / 0x1000; + *(s16 *)(spr + 0xA) = *(u16 *)(a0 + 0xA) - 0x34; + *(s16 *)(spr + 0xE) = *(u16 *)(a0 + 0xE) - (func_80047948(m) * 0x6C) / 0x1000; + *(s32 *)(spr + 0x14) = 0x40000; + *(s32 *)(spr + 0x10) = -(func_8004787C(m) * 0xC0); + *(s32 *)(spr + 0x18) = -(func_80047948(m) * 0xC0); + } + t = *(u16 *)(a0 + 0x104) + 0x100; + *(s16 *)(a0 + 0x104) = t; + ang = (s16)t; + idx = ang / 0x100; + m = (s16)(idx % 0x10); + if (ang == 0x100) { + RTP_SND(0x95F) // !FAKE: instruction via RTP_SND — REFUSED macro-carried instruction: the lever is inside `#define RTP_SND` with real code around it (T5) (P36 rung B tus9) + } else if (m == 0) { + RTP_SND(0x960) // !FAKE: instruction via RTP_SND — REFUSED macro-carried instruction: the lever is inside `#define RTP_SND` with real code around it (T5) (P36 rung B tus9) + } + *(s32 *)(*(s32 *)(a0 + 0x20) + 0x20) = D_801D591C[m]; + c = *(u16 *)(a0 + 0x100) - 1; + *(s16 *)(a0 + 0x100) = c; + if ((s16)c == 0) { + p = *(s32 *)(a0 + 0xCC); + *(s16 *)(a0 + 0x98) = 1; + if (p != 0) { + *(s16 *)(p + 0x98) = 1; + } + p = *(s32 *)(a0 + 0xD0); + if (p != 0) { + *(s16 *)(p + 0x98) = 1; + } + } + } else if ((*(u16 *)(a0 + 0x72) & 0x4000) != 0) { + *(s16 *)(a0 + 0x2) = 7; + *(s16 *)(a0 + 0x100) = 0x3C; + func_8012A828(a0, D_801DCDDC); + p = *(s32 *)(a0 + 0xCC); + if (p != 0) { + func_8012A828(p, D_801DCE64); + } + p = *(s32 *)(a0 + 0xD0); + if (p != 0) { + func_8012A828(p, D_801DCEEC); + } + } +} + + + +extern void func_8012B370(int a0); +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); + +void func_801897DC(s32 a0) { + + extern u8 D_800AF648; + + struct { + s16 v[3]; /* sp+0x10 */ + s16 pad1; /* sp+0x16 */ + u16 sxy[2]; /* sp+0x18 */ + s32 z; /* sp+0x1C */ + s32 flag; /* sp+0x20 */ + } L; + + s16 hp; + s32 p; + + hp = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x14); + if (hp < 0x301) { + s32 count; + s32 total; + + count = *(u16 *)(a0 + 0xFC); + total = *(u16 *)(a0 + 0xFE); + count = count + 1; + total = total + count; + *(u16 *)(a0 + 0xFC) = count; + *(u16 *)(a0 + 0xFE) = total; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) = + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) + total; + } else { + p = *(s32 *)(a0 + 0xD0); + *(s16 *)(a0 + 2) = 3; + *(s32 *)(a0 + 0x1C) = 0x1E; + *(s16 *)(a0 + 0x98) = 0; + *(s16 *)(p + 2) = 3; + *(s32 *)(p + 0x1C) = 0x1E; + *(s16 *)(p + 0x98) = 0; + + L.v[0] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x48); + L.v[1] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x4C); + L.v[2] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x50); + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_8004914C(r4); } // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + { void *r4; r4 = &D_800AF648; func_800491AC(r4); } + RotTransPers((s32)L.v, (s32)L.sxy, &L.z, &L.flag); + if (L.flag >= 0 && (u32)((L.sxy[0] + 0xEF) & 0xFFFF) < 0x1DF + && (u32)((L.sxy[1] + 0xB3) & 0xFFFF) < 0x167) { + s32 x = (s16)L.sxy[0]; + s32 ax; + ax = x; + if (x < 0) { + ax = -x; + } + ax = ((0xF0 - ax) * 0x7F) / 0xF0; + x = (x + 0xF0) / 0x1E; + if (x == 0x10) { + x = 0xF; + } + x = x << 8; + func_8002D4C8(0x961, (ax | (0x3000 | x)) & 0xFFFF); + } + } + func_8012B370(a0); +} + + +extern s32 func_801823F0(s32 a0); + +/* func_801899AC -- ov_SC06_008, TU ov_SC06_008_jr_8017C294.c (family of 7) + * + * Low-HP flinch/knockback reaction. hp = *(s16*)(a0->0x20 ptr + 0x14). If + * 0 < hp < 0xD00, put self AND the partner at a0->0xCC into stagger state 3 + * (a 0x1E-frame timer, status flag cleared), compute a screen-space + * position via RotTransPers and play a positional sound. Otherwise + * (hp==0 or hp>=0xD00) apply the accumulated hit-combo counter (0xFC/0xFE) + * to the target's HP and re-mask its low 12 bits. + * + * §136c sibling-first: the RTP + positional-sound tail is the byte-proven + * RTP_SND form from func_8018165C in this same TU (line 4746) -- v[]/pad, + * u16 sxy[2], s32 z, s32 flag, and the ax/x div-by-0xF0 / div-by-0x1E + * magic-constant idiom (0x88888889); also confirmed against func_801823F0 + * (same TU) which reuses the identical sndid 0x961 and the identical + * `sx = (sx + 0xF0) / 0x1E; if (sx == 0x10) sx = 0xF; sx <<= 8;` tail. + * + * Control flow: gcc-2.7.2 lays out basic blocks in literal SOURCE order, not + * by fallthrough-preference. A nested-if spelling (`if (hp<0xD00) { state=3; + * if (hp!=0) { B; goto end; } } A; end:`) places B (textually the inner + * then-body) inline right after the tests and relocates A after it -- the + * REVERSE of the target, which has the short block A inline and the long + * RTP+sound block B out-of-line. Explicit goto/label with A written BEFORE B + * in source (`if (hp>=0xD00) goto L_A; state=3; if (hp!=0) goto L_B; L_A: A; + * goto L_end; L_B: B; L_end: ...`) reproduces the target's physical layout + * directly -- no branch-polarity inversion needed, just source ORDER. + * + * Frame: RotTransPers args are sp+0x10 (v), sp+0x18 (&sxy), sp+0x1C (&z), + * sp+0x20 (&flag); v[3]+pad1 fills 0x10-0x17, sxy 0x18-0x1B, z 0x1C-0x1F, + * flag 0x20-0x23 -- leaves a dead 4 bytes (0x24-0x27) before the s0 save at + * 0x28. A trailing `pad2` dead struct member (same aggregate, so it can't + * be eliminated) reserves those 4 bytes, mirroring func_8018165C's own + * "dead aggregate sizes the frame" idiom (comment there: idiom 6). + */ + +extern void func_8012B370(int a0); +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); + +void func_801899AC(s32 a0) { + + extern u8 D_800AF648; + + struct { + s16 v[3]; /* sp+0x10 */ + s16 pad1; /* sp+0x16 */ + u16 sxy[2]; /* sp+0x18 */ + s32 z; /* sp+0x1C */ + s32 flag; /* sp+0x20 */ + s32 pad2; /* sp+0x24 -- dead, sizes the frame */ + } L; + + s16 hp; + s32 state; + s32 p; + + hp = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x14); + if (hp >= 0xD00) { + goto L_A; + } + state = 3; + if (hp != 0) { + goto L_B; + } + +L_A: + { + s32 count; + s32 total; + + count = *(u16 *)(a0 + 0xFC); + total = *(u16 *)(a0 + 0xFE); + count = count + 1; + total = total + count; + *(u16 *)(a0 + 0xFC) = count; + *(u16 *)(a0 + 0xFE) = total; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) = + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) - total; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) = + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) & 0xFFF; + } + goto L_end; + +L_B: + p = *(s32 *)(a0 + 0xCC); + *(s16 *)(a0 + 2) = state; + *(s32 *)(a0 + 0x1C) = 0x1E; + *(s16 *)(a0 + 0x98) = 0; + *(s16 *)(p + 2) = state; + *(s32 *)(p + 0x1C) = 0x1E; + *(s16 *)(p + 0x98) = 0; + + L.v[0] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x48); + L.v[1] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x4C); + L.v[2] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x50); + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_8004914C(r4); } // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + { void *r4; r4 = &D_800AF648; func_800491AC(r4); } + RotTransPers((s32)L.v, (s32)L.sxy, &L.z, &L.flag); + if (L.flag >= 0 && (u32)((L.sxy[0] + 0xEF) & 0xFFFF) < 0x1DF + && (u32)((L.sxy[1] + 0xB3) & 0xFFFF) < 0x167) { + s32 sx = (s16)L.sxy[0]; + s32 av; + av = sx; + if (sx < 0) { + av = -sx; + } + av = ((0xF0 - av) * 0x7F) / 0xF0; + sx = (sx + 0xF0) / 0x1E; + if (sx == 0x10) { + sx = 0xF; + } + sx = sx << 8; + func_8002D4C8(0x961, (av | (0x3000 | sx)) & 0xFFFF); + } + +L_end: + func_8012B370(a0); +} + + +extern s32 func_8012C044(s32 a0); +extern void func_8012C098(void *param_1); +extern void func_8012C218(void *a0); +extern int func_80143C74(short *, int); +extern s32 rand(void); + +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); +extern void func_8002D4C8(s32 a0, s32 a1); + +void func_80189B9C(s32 a0) +{ + + extern void (*D_801D5AC8[])(void); + extern u8 D_800AF648; + struct { + s16 v[3]; /* sp+0x10 */ + s16 pad1; /* sp+0x16 */ + u16 sxy[2]; /* sp+0x18 */ + s32 z; /* sp+0x1C */ + s32 flag; /* sp+0x20 */ + } L; + + D_801D5AC8[*(u16 *)(a0 + 0x2)](); + + if (*(u16 *)(a0 + 0x0) != 0) { + if (*(s16 *)(a0 + 0x70) == 0 && func_8012C044(a0) != 0) { + if (*(s32 *)(a0 + 0xCC) != 0) { + func_8012C218(*(void **)(a0 + 0xCC)); + } + if (*(s32 *)(a0 + 0xD0) != 0) { + func_8012C218(*(void **)(a0 + 0xD0)); + } + func_8012C098((void *)a0); + } else { + s16 v; + + v = *(s16 *)(a0 + 0xE2); + if (v != 0) { + v = v - 1; + *(s16 *)(a0 + 0xE2) = v; + if (v == 0) { + *(u16 *)(a0 + 0x5C) &= 0xBFFF; + } + } + + if ((*(s16 *)(a0 + 0x76) < 5) && ((rand() & 3) == 0)) { + s32 iVar2 = ((s32 (*)(s32, s32))func_80143C74)(a0, 0); + s32 r; + + if (iVar2 != 0) { + r = rand(); + *(s32 *)(iVar2 + 0x10) = ((r & 0x7FF) - 0x400) << 8; + *(s32 *)(iVar2 + 0x14) = 0xFFF00000; + r = rand(); + *(s32 *)(iVar2 + 0x18) = ((r & 0x7FF) - 0x400) << 8; + r = rand(); + *(u16 *)(iVar2 + 0x6) -= 0x20; + *(u16 *)(iVar2 + 0x6) += (r & 0x3F); + *(s16 *)(iVar2 + 0xA) -= 0xC0; + r = rand(); + *(u16 *)(iVar2 + 0xE) -= 0x20; + *(u16 *)(iVar2 + 0xE) += (r & 0x3F); + } + } + + if (*(u16 *)(a0 + 0x2) != 1 && *(u16 *)(a0 + 0x2) != 5) { + *(s16 *)(a0 + 0x84) = 0xE; + } else { + if (*(s16 *)(a0 + 0x84) != 0) { + *(s16 *)(a0 + 0x84) = *(s16 *)(a0 + 0x84) - 1; + } else { + *(s16 *)(a0 + 0x84) = 0xE; + + L.v[0] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x48); + L.v[1] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x4C); + L.v[2] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x50); + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_8004914C(r4); } // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + { void *r4; r4 = &D_800AF648; func_800491AC(r4); } + RotTransPers((s32)L.v, (s32)L.sxy, &L.z, &L.flag); + if (L.flag >= 0 && (u32)((L.sxy[0] + 0xEF) & 0xFFFF) < 0x1DF + && (u32)((L.sxy[1] + 0xB3) & 0xFFFF) < 0x167) { + s32 x = (s16)L.sxy[0]; + s32 ax; + ax = x; + if (x < 0) { + ax = -x; + } + ax = ((0xF0 - ax) * 0x7F) / 0xF0; + x = (x + 0xF0) / 0x1E; + if (x == 0x10) { + x = 0xF; + } + x = x << 8; + { + s32 flg = 0x3000; + func_8002D4C8(0x8BF, ((ax | flg) | x) & 0xFFFF); + } + } + } + } + } + } +} + + + +// @class: plumbing +// @stuck: none — MATCH (126 ins). Keys: (1) cVar1 as `int` (not unsigned char) so the +// lbu-loaded byte stays full-width and gcc omits the per-compare `andi 0xff`; (2) uninitialized +// `int unaff_s1` -> $s1 (live-from-entry across func_8002D4C8); (3) func_8016AA50 takes TWO args +// (param_1, unaff_s1) — a1=unaff_s1 arg-setup is reused by the preceding subtraction and a0=s0 +// hoists into the branch delay slot; (4) 0x76 read UNSIGNED (lhu) in the subtract, SIGNED (lh) in +// the `< 1` test. + +extern void func_8002D4C8(int, int); +extern void func_8016AA50(int, int); +extern s32 func_8016B428(s32); +extern void func_80019064(void *); +extern void func_8002A520(int); +extern void func_8002A790(int); +extern void func_80131E00(int, int); + +void func_80189EB4(int param_1) +{ + + extern unsigned char D_801D5A38[]; + int cVar1; + int unaff_s1; + + cVar1 = *(unsigned char *)(param_1 + 0x5e); + *(char *)(param_1 + 0xc1) = 0; + *(short *)(param_1 + 0x5e) = 0; + *(unsigned short *)(param_1 + 0x5c) = *(unsigned short *)(param_1 + 0x5c) & 0xfffe; + if (*(short *)(param_1 + 0xfc) == 0) { + *(int *)(param_1 + 4) = *(int *)(*(int *)(param_1 + 0x64) + 4); + *(int *)(param_1 + 8) = *(int *)(*(int *)(param_1 + 0x64) + 8); + *(int *)(param_1 + 0xc) = *(int *)(*(int *)(param_1 + 0x64) + 0xc); + *(unsigned short *)(*(int *)(param_1 + 0x20) + 0x10) = + *(unsigned short *)(*(int *)(*(int *)(param_1 + 0x64) + 0x20) + 0x10); + *(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) = + *(unsigned short *)(*(int *)(*(int *)(param_1 + 0x64) + 0x20) + 0x12); + *(unsigned short *)(*(int *)(param_1 + 0x20) + 0x14) = + *(unsigned short *)(*(int *)(*(int *)(param_1 + 0x64) + 0x20) + 0x14); + } + if (*(short *)(param_1 + 0x102) == 0) { + *(short *)(param_1 + 0x102) = 10; + *(unsigned short *)(param_1 + 0x5c) = *(unsigned short *)(param_1 + 0x5c) | 0x4000; + func_8002D4C8(0x9b7, 0); + if (*(short *)(param_1 + 0x60) != 0) { + if (cVar1 == 0x1d) { + *(short *)(param_1 + 0x82) = 0; + *(short *)(param_1 + 0x7c) = *(unsigned short *)(param_1 + 6); + *(short *)(param_1 + 0x7e) = *(unsigned short *)(param_1 + 0xa); + *(short *)(param_1 + 0x80) = *(unsigned short *)(param_1 + 0xe); + } + if (*(int *)(param_1 + 0x78) != 0) { + unaff_s1 = (int)*(short *)(param_1 + 0x60) * + (int)*(short *)(*(int *)(param_1 + 0x78) + 0x30) >> 0xc; + if (unaff_s1 < 1) { + unaff_s1 = 1; + } + } + *(unsigned short *)(param_1 + 0x76) = + *(unsigned short *)(param_1 + 0x76) - unaff_s1; + func_8016AA50(param_1, unaff_s1); + if ((*(unsigned short *)(param_1 + 0x82) & 1) != 0) { + ((void (*)(int))func_8016B428)(param_1); + func_80019064(D_801D5A38); + } + } + if (cVar1 != 0x1d) { + if (*(unsigned char *)(param_1 + 0xc8) != 0) { + func_8002A520(param_1); + } + if (*(unsigned char *)(param_1 + 0xc9) != 0) { + func_8002A790(param_1); + } + } + if (*(short *)(param_1 + 0x76) < 1) { + *(short *)(param_1 + 0x5c) = 0; + func_80131E00(param_1, 6); + } + } + return; +} + + + + + +extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2); +extern s32 func_8012C588(s32 a0, s32 a1); +extern void func_8012C218(void *a0); +extern u8 *func_8012913C(s32 a0); +extern s32 func_80047948(s32 a0); +extern s32 func_8004787C(s32 a0); +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern s32 VectorNormalSS(void *a0, void *a1); +extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 rand(void); + +void func_8018A0AC(s32 a0) { + + extern s32 D_801151D4; + + extern void func_8002AC00(s32 arg0); + extern void func_8002A04C(s32 arg0); + extern u8 D_800AF648; + + u16 v10[4]; /* sp+0x10 */ + s16 v18[4]; /* sp+0x18 */ + s32 sxy; /* sp+0x20 */ + s32 z; /* sp+0x24 */ + s32 flag; /* sp+0x28 */ + s32 base; + s32 iv; + s32 i; + s32 t; + s32 r; + + base = D_801151D4; + + if (*(s16 *)(a0 + 0xFC) >= 0x1F) { + iv = func_8012C658(0x33, 3, a0); + if (iv != 0) { + *(u16 *)(iv + 0x0A) = *(u16 *)(iv + 0x0A) - 0x20; + *(u16 *)(iv + 0x12) = *(u16 *)(iv + 0x12) - 8; + *(u16 *)(iv + 0x1A) = *(u16 *)(iv + 0x1A) - 5; + } + iv = func_8012C658(0x33, 3, a0); + if (iv != 0) { + *(u16 *)(iv + 0x0A) = *(u16 *)(iv + 0x0A) - 0x20; + *(u16 *)(iv + 0x12) = *(u16 *)(iv + 0x12) - 8; + *(u16 *)(iv + 0x1A) = *(u16 *)(iv + 0x1A) + 5; + } + iv = func_8012C658(0x32, 2, a0); + if (iv != 0) { + *(u16 *)(iv + 0x0A) = *(u16 *)(iv + 0x0A) - 0x20; + *(u16 *)(iv + 0x12) = *(u16 *)(iv + 0x12) + 8; + } + + func_8002AC00(0x22); + + iv = *(s32 *)(a0 + 0x64); + *(s16 *)(iv + 2) = 2; + iv = *(s32 *)(*(s32 *)(a0 + 0x64) + 0xD0); + *(s16 *)(iv + 2) = 4; + *(s32 *)(*(s32 *)(a0 + 0x64) + 0xCC) = 0; + + i = 0; + do { + iv = func_8012C588(0x281, a0); + if (iv != 0) { + *(s32 *)(iv + 0x1C) = 2; + *(s16 *)(iv + 0x12) = (rand() & 0x1F) - 0x10; + *(s16 *)(iv + 0x16) = -((rand() & 0x0F) + 0x10); + *(s16 *)(iv + 0x1A) = (rand() & 0x1F) - 0x10; + } + i++; + } while (i < 8); + + v18[0] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x48); + v18[1] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x4C); + v18[2] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x50); + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_8004914C(r4); } // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + { void *r4; r4 = &D_800AF648; func_800491AC(r4); } + RotTransPers((s32)v18, (s32)&sxy, &z, &flag); + if (flag >= 0 && (u32)((*(u16 *)&sxy + 0xEF) & 0xFFFF) < 0x1DF + && (u32)((*((u16 *)&sxy + 1) + 0xB3) & 0xFFFF) < 0x167) { + s32 sx; + s32 av; + + sx = (s16)*(u16 *)&sxy; + av = sx; + if (sx < 0) { + av = -sx; + } + /* one local for |x| AND the volume: gcc-2.7.2 keeps the single pseudo + in $v1 in place (subu $v1,$v0,$v1); a separate `vol` local steals $a1 + and the whole OR chain drifts (cookbook §136 L1). */ + av = ((0xF0 - av) * 0x7F) / 0xF0; + sx = (sx + 0xF0) / 0x1E; + if (sx == 0x10) { + sx = 0xF; + } + sx = sx << 8; + func_8002D4C8(0x961, (av | (0x3000 | sx)) & 0xFFFF); + } + + func_8002A04C(a0); + func_8012C218((void *)a0); + return; + } + + iv = (s32)func_8012913C(0x23); + if (iv != 0) { + r = rand(); + *(u16 *)(iv + 0x06) = *(u16 *)(a0 + 0x06) + (r & 0x7F) - 0x40; + r = rand(); + *(u16 *)(iv + 0x0A) = *(u16 *)(a0 + 0x0A) + (r & 0x7F) - 0x80; + r = rand(); + *(u16 *)(iv + 0x0E) = *(u16 *)(a0 + 0x0E) + (r & 0x7F) - 0x40; + + t = func_80047948((s32) * (s16 *)(*(s32 *)(a0 + 0x20) + 0x12)); + *(s32 *)(iv + 0x04) = *(s32 *)(iv + 0x04) + (t << 10); + + t = func_8004787C((s32) * (s16 *)(*(s32 *)(a0 + 0x20) + 0x12)); + *(u16 *)(iv + 0x34) = 0x1800; + *(s32 *)(iv + 0x18) = 0; + *(s32 *)(iv + 0x14) = 0; + *(s32 *)(iv + 0x10) = 0; + *(s32 *)(iv + 0x0C) = *(s32 *)(iv + 0x0C) - (t << 10); + + v10[0] = *(s32 *)(base + 0x5C) - *(u16 *)(iv + 0x06); + v10[1] = *(s32 *)(base + 0x60) - *(u16 *)(iv + 0x0A); + v10[2] = *(s32 *)(base + 0x64) - *(u16 *)(iv + 0x0E); + VectorNormalSS(v10, v10); + + *(u16 *)(iv + 0x06) = *(u16 *)(iv + 0x06) + ((s16)v10[0] >> 6); + *(u16 *)(iv + 0x0A) = *(u16 *)(iv + 0x0A) + ((s16)v10[1] >> 6); + *(u16 *)(iv + 0x0E) = *(u16 *)(iv + 0x0E) + ((s16)v10[2] >> 6); + *(u16 *)(iv + 0x34) = 0x3000; + func_8002D4C8(0xAF8, 0); + } + + *(u16 *)(a0 + 0xFC) = *(u16 *)(a0 + 0xFC) + 1; +} + + + +// @class: struct +// @stuck: none — MATCH + +extern int rand(void); +extern int func_80143C74(short *, int); +extern int func_80047948(int); +extern int func_8004787C(int); + +void func_8018A4F4(short *param_1) +{ + + extern void (*D_801D5B50[])(short *); + int iVar3; + unsigned int uVar2; + short v; + + v = param_1[0x81]; + if (v != 0) { + v = v - 1; + param_1[0x81] = v; + if (v == 0) { + *(unsigned short *)(param_1 + 0x2e) &= 0xbfff; + } + } + D_801D5B50[*(unsigned short *)(param_1 + 1)](param_1); + if (*(unsigned short *)param_1 != 0) { + if (param_1[0x7e] == 0) { + *(int *)(param_1 + 2) = *(int *)(*(int *)(param_1 + 0x32) + 4); + *(int *)(param_1 + 4) = *(int *)(*(int *)(param_1 + 0x32) + 8); + *(int *)(param_1 + 6) = *(int *)(*(int *)(param_1 + 0x32) + 0xc); + *(unsigned short *)(*(int *)(param_1 + 0x10) + 0x10) = + *(unsigned short *)(*(int *)(*(int *)(param_1 + 0x32) + 0x20) + 0x10); + *(unsigned short *)(*(int *)(param_1 + 0x10) + 0x12) = + *(unsigned short *)(*(int *)(*(int *)(param_1 + 0x32) + 0x20) + 0x12); + *(unsigned short *)(*(int *)(param_1 + 0x10) + 0x14) = + *(unsigned short *)(*(int *)(*(int *)(param_1 + 0x32) + 0x20) + 0x14); + } + if ((param_1[0x3b] < 5) && ((rand() & 3) == 0) && + ((iVar3 = func_80143C74(param_1, 0)) != 0)) { + uVar2 = rand(); + *(int *)(iVar3 + 0x10) = ((uVar2 & 0x7ff) - 0x400) * 0x100; + *(unsigned int *)(iVar3 + 0x14) = 0xfff00000; + uVar2 = rand(); + *(int *)(iVar3 + 0x18) = ((uVar2 & 0x7ff) - 0x400) * 0x100; + *(int *)(iVar3 + 4) += + func_80047948((int)*(short *)(*(int *)(param_1 + 0x10) + 0x12)) * 0x400; + *(int *)(iVar3 + 0xc) -= + func_8004787C((int)*(short *)(*(int *)(param_1 + 0x10) + 0x12)) * 0x400; + uVar2 = rand(); + *(short *)(iVar3 + 6) -= 0x20; + *(short *)(iVar3 + 6) += (uVar2 & 0x3f); + *(short *)(iVar3 + 0xa) -= 0x40; + uVar2 = rand(); + *(short *)(iVar3 + 0xe) -= 0x20; + *(short *)(iVar3 + 0xe) += (uVar2 & 0x3f); + } + } + return; +} + + + + +extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2); +extern s32 func_8012C588(s32 a0, s32 a1); +extern void func_8012C218(void *a0); +extern u8 *func_8012913C(); +extern s32 rand(void); +extern s32 func_80047948(s32 a0); +extern s32 func_8004787C(s32 a0); +extern s32 VectorNormalSS(void *a0, void *a1); +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); +extern void func_8002A04C(s32 a0); + + +void func_8018A704(s32 a0) { + + extern s32 D_801151D4; + + extern u8 D_800AF648; + extern void func_8002AC00(s32 arg0); + + struct { + u16 nv[4]; /* sp+0x10 */ + s16 v[4]; /* sp+0x18 */ + u16 sxy[2]; /* sp+0x20 */ + s32 z; /* sp+0x24 */ + s32 flag; /* sp+0x28 */ + } L; + s32 p; + s32 s0; + s32 i; + + p = D_801151D4; + + if (*(s16 *)(a0 + 0xFC) >= 0x1F) { + s0 = func_8012C658(0x33, 3, a0); + if (s0 != 0) { + *(s16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) - 0x20; + *(s16 *)(s0 + 0x12) = *(u16 *)(s0 + 0x12) - 8; + *(s16 *)(s0 + 0x1A) = *(u16 *)(s0 + 0x1A) - 5; + } + s0 = func_8012C658(0x33, 3, a0); + if (s0 != 0) { + *(s16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) - 0x20; + *(s16 *)(s0 + 0x12) = *(u16 *)(s0 + 0x12) - 8; + *(s16 *)(s0 + 0x1A) = *(u16 *)(s0 + 0x1A) + 5; + } + s0 = func_8012C658(0x32, 2, a0); + if (s0 != 0) { + *(s16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) - 0x20; + *(s16 *)(s0 + 0x12) = *(u16 *)(s0 + 0x12) + 8; + } + func_8002AC00(0x22); + s0 = *(s32 *)(a0 + 0x64); + *(s16 *)(s0 + 0x2) = 4; + s0 = *(s32 *)(*(s32 *)(a0 + 0x64) + 0xCC); + *(s16 *)(s0 + 0x2) = 4; + + for (i = 0; i < 8; i++) { + s0 = func_8012C588(0x281, a0); + if (s0 != 0) { + *(s32 *)(s0 + 0x1C) = 2; + *(s16 *)(s0 + 0x12) = (rand() & 0x1F) - 0x10; + *(s16 *)(s0 + 0x16) = -((rand() & 0xF) + 0x10); + *(s16 *)(s0 + 0x1A) = (rand() & 0x1F) - 0x10; + } + } + + L.v[0] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x48); + L.v[1] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x4C); + L.v[2] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x50); + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_8004914C(r4); } // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + { void *r4; r4 = &D_800AF648; func_800491AC(r4); } + RotTransPers((s32)L.v, (s32)L.sxy, &L.z, &L.flag); + if (L.flag >= 0 && (u32)((L.sxy[0] + 0xEF) & 0xFFFF) < 0x1DF + && (u32)((L.sxy[1] + 0xB3) & 0xFFFF) < 0x167) { + s32 x = (s16)L.sxy[0]; + s32 ax; + ax = x; + if (x < 0) { + ax = -x; + } + ax = ((0xF0 - ax) * 0x7F) / 0xF0; + x = (x + 0xF0) / 0x1E; + if (x == 0x10) { + x = 0xF; + } + x = x << 8; + { + s32 flg = 0x3000; + func_8002D4C8(0x961, ((ax | flg) | x) & 0xFFFF); + } + } + + *(s32 *)(*(s32 *)(a0 + 0x64) + 0xD0) = 0; + func_8002A04C(a0); + func_8012C218((void *)a0); + return; + } + + s0 = (s32)func_8012913C(0x23); + if (s0 != 0) { + *(s16 *)(s0 + 0x6) = *(u16 *)(a0 + 0x6) + (rand() & 0x7F) - 0x40; + *(s16 *)(s0 + 0xA) = *(u16 *)(a0 + 0xA) + (rand() & 0x7F) - 0x80; + *(s16 *)(s0 + 0xE) = *(u16 *)(a0 + 0xE) + (rand() & 0x7F) - 0x40; + + *(s32 *)(s0 + 0x4) = + *(s32 *)(s0 + 0x4) - + func_80047948(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12)) * 0x400; + { + s32 t = func_8004787C(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12)) * 0x400; + *(s16 *)(s0 + 0x34) = 0x1800; + *(s32 *)(s0 + 0x18) = 0; + *(s32 *)(s0 + 0x14) = 0; + *(s32 *)(s0 + 0x10) = 0; + *(s32 *)(s0 + 0xC) = *(s32 *)(s0 + 0xC) + t; + } + + L.nv[0] = *(s32 *)(p + 0x5C) - *(u16 *)(s0 + 0x6); + L.nv[1] = *(s32 *)(p + 0x60) - *(u16 *)(s0 + 0xA); + L.nv[2] = *(s32 *)(p + 0x64) - *(u16 *)(s0 + 0xE); + VectorNormalSS(L.nv, L.nv); + + *(s16 *)(s0 + 0x6) = *(u16 *)(s0 + 0x6) + ((s16)L.nv[0] >> 6); + *(s16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) + ((s16)L.nv[1] >> 6); + *(s16 *)(s0 + 0xE) = *(u16 *)(s0 + 0xE) + ((s16)L.nv[2] >> 6); + *(s16 *)(s0 + 0x34) = 0x3000; + func_8002D4C8(0xAF8, 0); + } + + *(s16 *)(a0 + 0xFC) = *(u16 *)(a0 + 0xFC) + 1; +} + + + +extern s32 rand(void); +extern s32 func_80143C74(); +extern s32 func_80047948(s32 a0); +extern s32 func_8004787C(s32 a0); + +void func_8018AB48(s32 a0) { + + extern void (*D_801D5BC8[])(s32); + s32 iVar3; + s32 iVar4; + s32 r; + + { + s16 t = *(s16 *)(a0 + 0x102); + if (t != 0) { + t--; + *(s16 *)(a0 + 0x102) = t; + if (t == 0) { + *(u16 *)(a0 + 0x5C) &= 0xBFFF; + } + } + } + + D_801D5BC8[*(u16 *)(a0 + 2)](a0); + + if (*(u16 *)(a0 + 0) != 0) { + if (*(s16 *)(a0 + 0xFC) == 0) { + *(s32 *)(a0 + 4) = *(s32 *)(*(s32 *)(a0 + 0x64) + 4); + *(s32 *)(a0 + 8) = *(s32 *)(*(s32 *)(a0 + 0x64) + 8); + *(s32 *)(a0 + 0xC) = *(s32 *)(*(s32 *)(a0 + 0x64) + 0xC); + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x10) = + *(s16 *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x10); + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) = + *(s16 *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x12); + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x14) = + *(s16 *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x14); + } + if (*(s16 *)(a0 + 0x76) < 5 && (rand() & 3) == 0 && + (iVar3 = func_80143C74(a0, 0)) != 0) { + *(s32 *)(iVar3 + 0x10) = ((rand() & 0x7FF) - 0x400) << 8; + *(s32 *)(iVar3 + 0x14) = 0xFFF00000; + *(s32 *)(iVar3 + 0x18) = ((rand() & 0x7FF) - 0x400) << 8; + iVar4 = func_80047948((s32) * (s16 *)(*(s32 *)(a0 + 0x20) + 0x12)); + *(s32 *)(iVar3 + 4) = *(s32 *)(iVar3 + 4) - iVar4 * 0x400; + iVar4 = func_8004787C((s32) * (s16 *)(*(s32 *)(a0 + 0x20) + 0x12)); + *(s32 *)(iVar3 + 0xC) = *(s32 *)(iVar3 + 0xC) + iVar4 * 0x400; + r = rand(); + { + s32 m6 = *(u16 *)(iVar3 + 6) - 0x20; + *(u16 *)(iVar3 + 6) = m6 + (r & 0x3F); + } + *(u16 *)(iVar3 + 0xA) = *(u16 *)(iVar3 + 0xA) - 0x40; + r = rand(); + { + s32 mE = *(u16 *)(iVar3 + 0xE) - 0x20; + *(u16 *)(iVar3 + 0xE) = mE + (r & 0x3F); + } + } + } +} + + + + +// @class: schedule +// @stuck: none — MATCH. Two levers: (1) split rand()-result into its own var (shared iVar1 forced an extra move a0,v0); (2) reorder decrement before sp[0] to group the two lhu loads as target's scheduler does; (3) materialize &D_80126B96 via a local u16* to CSE the address (lui+addiu once) instead of %hi/%lo split-per-access. + + + + + + + + +extern void func_80128EA8(); +extern void func_8012931C(); +extern s32 func_80128ED8(s32 param_1, s32 *param_2); +extern u8 *func_8012913C(); +extern void func_801292C8(); +extern int func_8012D664(); + +extern u16 D_801270C0; + +void func_8018AD58(s32 arg0) { + + extern u8 D_801D59AC; + extern u8 D_801D59B8; + extern u16 D_80126B96; + s32 iVar1; + s32 rv; + u8 *p; + u16 sp[3]; + + if (*(u16 *)(arg0 + 2) == 0) { + *(u8 **)(*(s32 *)(arg0 + 0x20) + 0x20) = &D_801D59AC; + *(u32 *)(*(s32 *)(arg0 + 0x20) + 4) |= 0x50000000; + *(u8 *)(*(s32 *)(arg0 + 0x20) + 0x27) = 0x59; + func_80128EA8(*(s32 *)(arg0 + 0x20), arg0 + 0x24, (s32)&D_801D59B8); + rv = rand(); + *(s32 *)(arg0 + 0x1c) = 0x10; + *(s32 *)(arg0 + 0x2c) = 0x200; + *(s16 *)(arg0 + 0x28) = rv % 15; + *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x18) = 0x1200; + *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x1a) = 0x1200; + *(u16 *)(arg0 + 2) = *(u16 *)(arg0 + 2) + 1; + } else if (*(s16 *)&D_801270C0 == 1) { + func_8012931C(arg0); + func_80128ED8(*(s32 *)(arg0 + 0x20), arg0 + 0x24); + *(s32 *)(arg0 + 0x1c) -= 1; + if ((rand() & 7) == 0 && (p = func_8012913C(0x22)) != 0) { + *(u16 *)(p + 6) = *(u16 *)(arg0 + 6); + *(u16 *)(p + 0xa) = *(u16 *)(arg0 + 0xa); + *(u16 *)(p + 0xe) = *(u16 *)(arg0 + 0xe); + *(s32 *)(p + 0x10) = *(s32 *)(arg0 + 0x10) >> 3; + *(s32 *)(p + 0x14) = *(s32 *)(arg0 + 0x14) >> 3; + *(s32 *)(p + 0x18) = *(s32 *)(arg0 + 0x18) >> 3; + *(s16 *)(p + 0x34) = *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x18) + 1; + *(u16 *)(*(s32 *)(p + 0x20) + 0x2c) = 0xc008; + } + if (*(s32 *)(arg0 + 0x1c) == 0) { + func_801292C8(arg0); + } else { + *(s32 *)(arg0 + 0x14) = 0xffff0000; + iVar1 = *(s32 *)(arg0 + 0x2c) + 0x80; + *(s32 *)(arg0 + 0x2c) = iVar1; + *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x18) = + *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x18) + (s16)iVar1; + *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x1a) = + *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x1a) + (s16)*(s32 *)(arg0 + 0x2c); + *(s16 *)(arg0 + 0xa) = *(s16 *)(arg0 + 0xa) - 0x20; + sp[0] = *(u16 *)(arg0 + 6); + sp[1] = *(u16 *)(arg0 + 0xa); + sp[2] = *(u16 *)(arg0 + 0xe); + if (func_8012D664(sp, 0x10, 0xb4) == 1) { + u16 *q = &D_80126B96; + *q |= 0x4200; + } + *(s16 *)(arg0 + 0xa) = *(s16 *)(arg0 + 0xa) + 0x20; + } + } +} + + +void func_8018AFDC(void *a0) { + s32 v1; + v1 = *(s32 *)((s32)a0 + 0xCC); + *(s16 *)((s32)a0 + 0x5C) = 0; + *(s16 *)((s32)a0 + 0xFC) = 0x1E; + *(s16 *)((s32)v1 + 0x5C) = 0; + v1 = *(s32 *)((s32)a0 + 0xD0); + *(s16 *)((s32)v1 + 0x5C) = 0; + } + + + +extern void func_8012B1B4(s32 a0, s32 a1); +extern void func_8012CBCC(s32 a0); +extern int func_80188754(int param_1, short param_2); +extern s32 func_8012B8E4(s32 arg0, s32 arg1); +extern void func_8012A828(s32 a0, void *a1); + +void func_8018AFFC(s32 a0) { + extern u8 D_801D5AB8[]; + extern u8 D_801DD274[]; + extern u8 D_801DD364[]; + extern u8 D_801DD454[]; + s32 pad[4]; + + func_8012B1B4(a0, (s32)D_801D5AB8); + func_8012CBCC(a0); + func_80188754(a0, 0x48); + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) += func_8012B8E4(a0, 0x10); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) &= 0xFFF; + + *(u16 *)(a0 + 0x100) -= 1; + if (*(s16 *)(a0 + 0x100) == 0) { + *(s16 *)(a0 + 2) = 6; + *(u16 *)(a0 + 0x100) = 0x2D; + *(s32 *)(a0 + 0x1C) = 0; + *(s16 *)(a0 + 0x104) = 0; + func_8012A828(a0, D_801DD274); + + if (*(s32 *)(a0 + 0xCC) != 0) { + func_8012A828(*(s32 *)(a0 + 0xCC), D_801DD364); + } + if (*(s32 *)(a0 + 0xD0) != 0) { + func_8012A828(*(s32 *)(a0 + 0xD0), D_801DD454); + } + } +} + + +extern void func_8012A828(s32 a0, void *a1); + +void func_8018B0FC(s32 a0) { + extern u8 D_801DCF74[]; + extern u8 D_801DD074[]; + extern u8 D_801DD174[]; + + if (*(s16 *)(a0 + 0x100) == 0) { + *(u16 *)(a0 + 2) = 1; + *(s16 *)(a0 + 0x100) = 0x3C; + func_8012A828(a0, D_801DCF74); + if (*(s32 *)(a0 + 0xCC) != 0) { + func_8012A828(*(s32 *)(a0 + 0xCC), D_801DD074); + } + if (*(s32 *)(a0 + 0xD0) != 0) { + func_8012A828(*(s32 *)(a0 + 0xD0), D_801DD174); + } + } else { + *(s16 *)(a0 + 0x100) = *(s16 *)(a0 + 0x100) - 1; + } +} + + + +extern void func_8012B370(int a0); +extern void func_8012C218(void *a0); +extern s32 func_8012C588(s32 a0, s32 a1); +extern s32 rand(void); + +void func_8018B19C(s32 a0) +{ + s32 t; + u32 *p; + + t = *(s32 *)(a0 + 0x1C) - 1; + *(s32 *)(a0 + 0x1C) = t; + + if (t != 0) { + p = *(u32 **)(a0 + 0x20); + p[1] ^= 0x80000000; + func_8012B370(a0); + + if ((*(s32 *)(a0 + 0x1C) & 0x3) != 0) { + s32 obj = func_8012C588(0x281, a0); + if (obj != 0) { + *(s32 *)(obj + 0x1C) = 2; + *(s16 *)(obj + 0x12) = (rand() & 0x1F) - 0x10; + *(s16 *)(obj + 0x16) = -((rand() & 0xF) + 0x10); + *(s16 *)(obj + 0x1A) = (rand() & 0x1F) - 0x10; + } + } + return; + } + + func_8012C218((void *)a0); +} + + +extern void func_8012A828(s32 a0, void *a1); + +void func_8018B25C(s32 a0) { + extern u8 D_801DCF74[]; + extern u8 D_801DD074[]; + extern u8 D_801DD174[]; + + if (*(s16 *)(a0 + 0xFC) == 0) { + *(u16 *)(a0 + 2) = 1; + func_8012A828(a0, D_801DCF74); + if (*(s32 *)(a0 + 0xCC) != 0) { + func_8012A828(*(s32 *)(a0 + 0xCC), D_801DD074); + } + if (*(s32 *)(a0 + 0xD0) != 0) { + func_8012A828(*(s32 *)(a0 + 0xD0), D_801DD174); + } + } else { + *(s16 *)(a0 + 0xFC) = *(s16 *)(a0 + 0xFC) - 1; + } +} + + + + + + + + + + + + + + + + + + + + +void func_8018B2F4(void *a0) +{ + s32 v0 = *((s32 *) (((s32) a0) + 0x64)); + *((s16 *) (v0 + 0x5C)) = 0; + ; + *((s16 *) ((*((s32 *) ((*((s32 *) (((s32) a0) + 0x64))) + 0xD0))) + 0x5C)) = 0; +} + + + + +extern s32 func_8012C354(s32 a0, s32 a1); +extern void func_8001C214(s32 a0, s32 a1); +extern void func_8012B030(s32 a0); +extern void func_8012A828(s32 a0, void *a1); +extern void func_8012B23C(s32 a0); + +void func_8018B314(s32 a0) { + + extern u8 D_801D5AFC[]; + extern u8 D_801DAA34[]; + extern u8 D_801DD074[]; + extern u8 D_801D5B30[]; + + s32 v0; + + v0 = func_8012C354(a0, (s32)D_801D5AFC); + if (v0 != 0) { + if (*(s16 *)(a0 + 0x70) != 0) { + func_8001C214(*(s32 *)(a0 + 0x20), (s32)D_801DAA34); + } + *(u8 *)(a0 + 0xC0) = 1; + *(s32 *)(a0 + 0xB4) = 0xFFFFDFDF; + func_8012B030(a0); + *(s16 *)(a0 + 0xAE) = 0x2100; + func_8012A828(a0, D_801DD074); + *(u16 *)(a0 + 2) = *(u16 *)(a0 + 2) + 1; + func_8012B23C(a0); + *(void **)(a0 + 0xBC) = D_801D5B30; + *(u32 *)(a0 + 0xC4) = *(u32 *)(a0 + 0xC4) | 2; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) | 0x10; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = 0x2400; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x2400; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = 0x2400; + } +} + + +void func_8018B404(void) { +} + +extern s32 func_8004787C(s32 a0); +extern s32 func_80047948(s32 a0); +extern void func_8012B370(int a0); + +void func_8018B40C(s32 a0) +{ + s32 s0 = a0; + register s32 v0 asm("$2"); // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus9) + register s32 v1 asm("$3"); // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9) + s32 temp; + + v0 = *(s16 *)(*(s32 *)(s0 + 0x20) + 0x14); + + if (v0 < 0x401) { + v0 = *(u16 *)(s0 + 0xFC); + v1 = *(u16 *)(s0 + 0xFE); + v0 = v0 + 1; + v1 = v1 + v0; + *(u16 *)(s0 + 0xFC) = v0; + *(u16 *)(s0 + 0xFE) = v1; + v0 = *(u16 *)(*(s32 *)(s0 + 0x20) + 0x14); + v0 = v0 + v1; + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x14) = v0; + v0 = *(u16 *)(s0 + 0xA); + v0 = v0 - 4; + *(u16 *)(s0 + 0xA) = v0; + v0 = func_80047948(*(s16 *)(*(s32 *)(s0 + 0x20) + 0x12)); + v0 = v0 << 6; + v1 = *(s32 *)(s0 + 0x4); + v1 = v1 + v0; + *(s32 *)(s0 + 0x4) = v1; + v0 = func_8004787C(*(s16 *)(*(s32 *)(s0 + 0x20) + 0x12)); + v0 = v0 << 6; + v1 = *(s32 *)(s0 + 0xC); + v1 = v1 - v0; + *(s32 *)(s0 + 0xC) = v1; + } else { + *(u16 *)(s0 + 0x2) = 0x3; + *(s32 *)(s0 + 0x1C) = 0x1E; + *(u16 *)(s0 + 0x98) = 0; + } + + func_8012B370(s0); +} + + + +extern void func_8012B370(int a0); +extern void func_8012C218(void *a0); +extern s32 func_8012C588(s32 a0, s32 a1); +extern s32 rand(void); + +void func_8018B4E0(s32 a0) +{ + s32 t; + u32 *p; + + t = *(s32 *)(a0 + 0x1C) - 1; + *(s32 *)(a0 + 0x1C) = t; + + if (t != 0) { + p = *(u32 **)(a0 + 0x20); + p[1] ^= 0x80000000; + func_8012B370(a0); + + if ((*(s32 *)(a0 + 0x1C) & 0x3) != 0) { + s32 obj = func_8012C588(0x281, a0); + if (obj != 0) { + *(s32 *)(obj + 0x1C) = 2; + *(s16 *)(obj + 0x12) = (rand() & 0x1F) - 0x10; + *(s16 *)(obj + 0x16) = -((rand() & 0xF) + 0x10); + *(s16 *)(obj + 0x1A) = (rand() & 0x1F) - 0x10; + } + } + return; + } + + func_8012C218((void *)a0); +} + + +extern void func_8012B370(int a0); + void func_8018B5A0(void) { + ((void (*)(void))func_8012B370)(); + } + + + + + + + + + + + + + + + + + + + + +void func_8018B5C0(void *a0) +{ + s32 v0 = *((s32 *) (((s32) a0) + 0x64)); + *((s16 *) (v0 + 0x5C)) = 0; + ; + *((s16 *) ((*((s32 *) ((*((s32 *) (((s32) a0) + 0x64))) + 0xCC))) + 0x5C)) = 0; +} + + + +extern s32 func_8012C354(s32 a0, s32 a1); +extern void func_8001C214(s32 a0, s32 a1); +extern void func_8012B030(); +extern void func_8012A828(s32 a0, void *a1); +extern void func_8012B23C(s32 a0); + +void func_8018B5E0(s32 a0) { + + extern u8 D_801D5B74[]; + extern u8 D_801DB7A0[]; + extern u8 D_801D5BA8[]; + extern u8 D_801DD174[]; + + s32 v0; + + v0 = func_8012C354(a0, (s32)D_801D5B74); + if (v0 != 0) { + if (*(s16 *)(a0 + 0x70) != 0) { + func_8001C214(*(s32 *)(a0 + 0x20), (s32)D_801DB7A0); + } + *(u8 *)(a0 + 0xC0) = 1; + *(s32 *)(a0 + 0xB4) = 0xFFFFDFDF; + func_8012B030(a0); + *(void **)(a0 + 0xBC) = D_801D5BA8; + *(s16 *)(a0 + 0xAE) = 0x2100; + *(u32 *)(a0 + 0xC4) = *(u32 *)(a0 + 0xC4) | 2; + func_8012A828(a0, D_801DD174); + *(u16 *)(a0 + 2) = *(u16 *)(a0 + 2) + 1; + func_8012B23C(a0); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) | 0x10; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = 0x2400; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x2400; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = 0x2400; + } +} + + +void func_8018B6D4(void) { +} + + +extern s32 func_80047948(s32 a0); +extern s32 func_8004787C(s32 a0); +extern void func_8012B370(s32 a0); + +void func_8018B6DC(s32 a0) { + s16 ang; + u16 cnt; + u16 acc; + + ang = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x14); + if (ang < 0xC00) { + if (ang != 0) { + goto state3; + } + } + + cnt = *(u16 *)(a0 + 0xFC); + acc = *(u16 *)(a0 + 0xFE); + cnt = cnt + 1; + acc = acc + cnt; + *(u16 *)(a0 + 0xFC) = cnt; + *(u16 *)(a0 + 0xFE) = acc; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) = + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) - acc; + + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) = + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) & 0xFFF; + + *(u16 *)(a0 + 0xA) = *(u16 *)(a0 + 0xA) - 8; + + *(s32 *)(a0 + 4) = *(s32 *)(a0 + 4) - + func_80047948(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12)) * 0x80; + + *(s32 *)(a0 + 0xC) = *(s32 *)(a0 + 0xC) + + func_8004787C(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12)) * 0x80; + goto tail; + +state3: + *(u16 *)(a0 + 2) = 3; + *(s32 *)(a0 + 0x1C) = 0x1E; + *(u16 *)(a0 + 0x98) = 0; + +tail: + func_8012B370(a0); +} + + + +extern void func_8012B370(int a0); +extern void func_8012C218(void *a0); +extern s32 func_8012C588(s32 a0, s32 a1); +extern s32 rand(void); + +void func_8018B7D0(s32 a0) +{ + s32 t; + u32 *p; + + t = *(s32 *)(a0 + 0x1C) - 1; + *(s32 *)(a0 + 0x1C) = t; + + if (t != 0) { + p = *(u32 **)(a0 + 0x20); + p[1] ^= 0x80000000; + func_8012B370(a0); + + if ((*(s32 *)(a0 + 0x1C) & 0x3) != 0) { + s32 obj = func_8012C588(0x281, a0); + if (obj != 0) { + *(s32 *)(obj + 0x1C) = 2; + *(s16 *)(obj + 0x12) = (rand() & 0x1F) - 0x10; + *(s16 *)(obj + 0x16) = -((rand() & 0xF) + 0x10); + *(s16 *)(obj + 0x1A) = (rand() & 0x1F) - 0x10; + } + } + return; + } + + func_8012C218((void *)a0); +} + + +extern void func_8012B370(int a0); + void func_8018B890(void) { + ((void (*)(void))func_8012B370)(); + } + + +extern s32 func_8004787C(s32 a0); +extern s32 func_80047948(s32 a0); +extern s32 func_80133784(s32 a0, void *a1, s32 a2); + +s32 func_8018B8B0(param_1, param_2) +s32 param_1; +s32 param_2; +{ + int iVar1; + unsigned int uVar2; + int iVar3; + SVECTOR sv1; + SVECTOR sv2; + + sv1.vx = *(short *)(param_1 + 6); + sv1.vy = *(short *)(param_1 + 0xa) + -0x20; + sv1.vz = *(short *)(param_1 + 0xe); + iVar1 = func_8004787C(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + iVar3 = (short)param_2; + sv2.vy = sv1.vy; + sv2.vx = sv1.vx - (short)(iVar1 * iVar3 >> 0xc); + iVar1 = func_80047948(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + sv2.vz = sv1.vz - (short)(iVar1 * iVar3 >> 0xc); + uVar2 = ((int (*)(int, SVECTOR *, SVECTOR *))func_80133784)(1, &sv1, &sv2); + if ((uVar2 & 0x8000) != 0) { + iVar1 = func_8004787C(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + *(short *)(param_1 + 6) = sv2.vx + (short)(iVar1 * iVar3 >> 0xc); + iVar1 = func_80047948(*(unsigned short *)(*(int *)(param_1 + 0x20) + 0x12) & 0xfff); + *(short *)(param_1 + 0xe) = sv2.vz + (short)(iVar1 * iVar3 >> 0xc); + return 1; + } + return 0; +} + + + +/* TU declares func_8018B9E8 as void(void) (S35 self-axis) but the asm takes + * $a0 as a pointer parameter — bind through a private C name. */ +extern void aF8017ED80(void *param_1) __asm__("func_8018B9E8"); + +void aF8017ED80(void *param_1) { + u8 *a0 = (u8 *)param_1; + s32 pad_[4]; + s32 iVar2; + u32 uVar1; + + if (*(u16 *)(a0 + 0x0) != 0) { + iVar2 = *(s32 *)(a0 + 0xCC); + *(u16 *)(iVar2 + 0x8) = *(u16 *)(a0 + 0x6); + *(u16 *)(iVar2 + 0xA) = *(u16 *)(a0 + 0xA); + *(u16 *)(iVar2 + 0xC) = *(u16 *)(a0 + 0xE); + *(u16 *)(iVar2 + 0x10) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10); + *(u16 *)(iVar2 + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + *(u16 *)(a0 + 0xFC); + *(u16 *)(iVar2 + 0x14) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14); + *(u16 *)(iVar2 + 0x18) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x18); + *(u16 *)(iVar2 + 0x1A) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x1A); + *(u16 *)(iVar2 + 0x1C) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x1C); + if (*(s32 *)(*(s32 *)(a0 + 0x20) + 0x4) < 0) { + register u32 val __asm__("$2"); // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus9) + val = *(u32 *)(iVar2 + 0x4); + uVar1 = val | 0x80000000; + } else { + __asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus9) + uVar1 = *(u32 *)(iVar2 + 0x4) & 0x7FFFFFFF; + } + *(u32 *)(iVar2 + 0x4) = uVar1; + + iVar2 = *(s32 *)(a0 + 0xD0); + *(u16 *)(iVar2 + 0x8) = *(u16 *)(a0 + 0x6); + *(u16 *)(iVar2 + 0xA) = *(u16 *)(a0 + 0xA); + *(u16 *)(iVar2 + 0xC) = *(u16 *)(a0 + 0xE); + *(u16 *)(iVar2 + 0x10) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10); + *(u16 *)(iVar2 + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + *(u16 *)(a0 + 0xFE); + *(u16 *)(iVar2 + 0x14) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14); + *(u16 *)(iVar2 + 0x18) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x18); + *(u16 *)(iVar2 + 0x1A) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x1A); + *(u16 *)(iVar2 + 0x1C) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x1C); + if (*(s32 *)(*(s32 *)(a0 + 0x20) + 0x4) < 0) { + register u32 val __asm__("$2"); // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus9) + val = *(u32 *)(iVar2 + 0x4); + uVar1 = val | 0x80000000; + } else { + __asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus9) + uVar1 = *(u32 *)(iVar2 + 0x4) & 0x7FFFFFFF; + } + *(u32 *)(iVar2 + 0x4) = uVar1; + } +} + + + +/* func_8018BBBC -- ov_SC06_008, TU ov_SC06_008_jr_8017C294.c (open-only h_norm + * cluster exemplar, 7 members). + * + * a0+0x0 : u16 active flag; 0 => early return. + * a0+0x84 : s16 sound cooldown timer. + * cooldown != 0 -> just decrement it. + * cooldown == 0 -> try to play a positional sound (RotTransPers screen + * projection of the parent's position, range-gated on + * screen X/Y, volume from the classic div-by-0xF0 / + * div-by-0x1E magic-constant idiom -- byte-proven sibling + * form is func_80181CF0 in this same TU, sndid 0x849 here + * vs 0x961 there), then unconditionally reset the timer + * to 0xA regardless of whether the sound actually played. + * a0+0xFC / 0xFE : running hit-combo accumulators, bumped by +/-0x280 every + * call (unconditional tail). + * Tail always calls ((void (*)(void *))func_8018B9E8)(a0) (the TU's canonical decl for this + * symbol is void(void) -- S35 self-axis -- so this draft binds its own + * private extern with the asm's real void(void*) shape). + * + * Control flow is EXPLICIT goto/label, mirroring source-order block + * placement (gcc-2.7.2 lays out basic blocks in literal source order, not by + * fallthrough preference -- see the func_80181CF0 comment, same TU): the + * cooldown!=0 decrement is the SHORT block and sits out-of-line (jumped to), + * the cooldown==0 RTP+sound block is the LONG block and sits inline + * (fallthrough), matching the target's physical layout exactly. + * + * MATCH levers (byte-proven, 2026-08-05): + * 1. Naive `if(old!=0){cool=old-1;}else{...}` folds trivially: reorg.c's + * delay-slot filler steals the single-insn decrement into the `bnez`'s + * own delay slot and retargets the branch straight to the join label + * (2 ins short of target). The target instead keeps a genuine copy + * (`addu $v1,$v0,zero`) in the delay slot and a SEPARATE `addiu $v0,$v1,-1` + * at the decrement site. Reproduced by pinning a second variable + * `register s32 v1 __asm__("$3")`, assigned UNCONDITIONALLY right after + * the load (`v1 = old;`) -- the scheduler places that copy in the + * branch's delay slot on its own, and the decrement (`cool = v1 - 1`) + * can no longer be folded away. `cool` is separately pinned to + * `__asm__("$2")` so its other def sites (the three `cool = 0xA` early + * exits) don't drift onto $3 by coalescing with v1. + * 2. The tail's `sh $v0,0x84($s0)` / `addu $a0,$s0,zero` order (store off + * the callee-saved pointer BEFORE reloading it into the call-argument + * register) needed a `__asm__ __volatile__("":::"memory")` fence right + * after the store -- without it, sched1 hoists the independent a0-reload + * ahead of the store even when the reload is written later in source. + * 3. Frame is -0x38, 8 bytes (2 words) larger than the natural -0x30 the + * locals alone produce; `pad2[2]` (dead, address never read) inside `L` + * reserves them, mirroring func_80181CF0's own "dead aggregate sizes the + * frame" idiom. + */ + + +/* §37/§124 def-side asm-label alias (P30 S1d class lever): the TU declares + * `extern void func_8018BBBC(void);` (L4082, L4091) for callers that invoke it with NO args, + * while the byte-true definition takes an s32 in $a0 -> `conflicting types`. Neither side can + * move (a no-prototype escape is illegal once a param promotes), so the DEFINITION gets a + * private C identifier and binds the emitted symbol with a GNU asm label. Zero blast radius: + * the TU's declaration never meets the definition, and the emitted symbol is unchanged. */ +void aF8017EF54(s32 a0) __asm__("func_8018BBBC"); + +void aF8017EF54(s32 a0) +{ + extern void func_8004914C(void *a0); + extern void func_800491AC(void *a0); + extern void func_8002D4C8(s32 a0, s32 a1); + extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); + extern u8 D_800AF648; + extern void func_8018B9E8(void); + struct { + s16 v[3]; /* sp+0x10 */ + s16 pad1; /* sp+0x16 */ + u16 sxy[2]; /* sp+0x18 */ + s32 z; /* sp+0x1C */ + s32 flag; /* sp+0x20 */ + s32 pad2[2]; /* sp+0x24 -- dead, sizes the frame */ + } L; + + s32 v1; + s32 cool; + s32 old; + + if (*(u16 *)(a0 + 0x0) == 0) { + return; + } + + old = *(s16 *)(a0 + 0x84); + v1 = old; + if (old != 0) { + goto L_dec; + } + + L.v[0] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x48); + L.v[1] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x4C); + L.v[2] = *(s32 *)(*(s32 *)(a0 + 0x20) + 0x50); + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_8004914C(r4); } // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + { void *r4; r4 = &D_800AF648; func_800491AC(r4); } + RotTransPers((s32)L.v, (s32)L.sxy, &L.z, &L.flag); + + if (L.flag < 0) { + cool = 0xA; + goto L_join; + } + if ((u32)((L.sxy[0] + 0xEF) & 0xFFFF) >= 0x1DF) { + cool = 0xA; + goto L_join; + } + if ((u32)((L.sxy[1] + 0xB3) & 0xFFFF) >= 0x167) { + goto L_snd_skip; + } + + { + s32 sx = (s16)L.sxy[0]; + s32 av; + + av = sx; + if (sx < 0) { + av = -sx; + } + av = ((0xF0 - av) * 0x7F) / 0xF0; + sx = (sx + 0xF0) / 0x1E; + if (sx == 0x10) { + sx = 0xF; + } + sx = sx << 8; + func_8002D4C8(0x849, (av | (0x3000 | sx)) & 0xFFFF); + } + +L_snd_skip: + cool = 0xA; + goto L_join; + +L_dec: + cool = v1 - 1; + +L_join: + *(s16 *)(a0 + 0x84) = cool; + __asm__ __volatile__("" ::: "memory"); // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus9) + + { + s32 p = a0; + *(u16 *)(p + 0xFC) = *(u16 *)(p + 0xFC) + 0x280; + *(u16 *)(p + 0xFE) = *(u16 *)(p + 0xFE) - 0x280; + ((void (*)(void *))func_8018B9E8)((void *)p); + } +} + + + +extern s32 rand(void); +extern s32 VectorNormalSS(void *a0, void *a1); +extern s32 func_8012C588(s32 a0, s32 a1); +extern u8 *func_8012913C(); +extern void func_8018B9E8(void); + +void func_8018BD68(s32 a0) +{ + + extern s32 D_801151D4; + u16 nv[4]; + s32 g; + s32 s0; + s32 idx; + + g = D_801151D4; + + if (*(u16 *)a0 != 0) { + idx = *(s32 *)(a0 + 0x1C) & 3; + switch (idx) { + case 0: + s0 = func_8012C588(0x281, a0); + if (s0 != 0) { + *(s32 *)(s0 + 0x1C) = 2; + *(s16 *)(s0 + 0x12) = (rand() & 0x1F) - 0x10; + *(s16 *)(s0 + 0x16) = -((rand() & 0xF) + 0x10); + *(s16 *)(s0 + 0x1A) = (rand() & 0x1F) - 0x10; + } + break; + case 1: + break; + case 2: + case 3: + s0 = (s32)func_8012913C(0x23); + if (s0 != 0) { + *(s16 *)(s0 + 0x6) = *(u16 *)(a0 + 0x6) + (rand() & 0x3F) - 0x20; + *(s16 *)(s0 + 0xA) = *(u16 *)(a0 + 0xA) + (rand() & 0x3F) - 0x30; + { + s32 r = rand(); + s32 t = *(u16 *)(a0 + 0xE); + *(s32 *)(s0 + 0x18) = 0; + *(s32 *)(s0 + 0x14) = 0; + *(s32 *)(s0 + 0x10) = 0; + *(s16 *)(s0 + 0xE) = t + (r & 0x3F) - 0x20; + } + *(s16 *)(s0 + 0x34) = (rand() & 0x17FF) + 0x800; + nv[0] = *(s32 *)(g + 0x5C) - *(u16 *)(s0 + 0x6); + nv[1] = *(s32 *)(g + 0x60) - *(u16 *)(s0 + 0xA); + nv[2] = *(s32 *)(g + 0x64) - *(u16 *)(s0 + 0xE); + VectorNormalSS(nv, nv); + *(s16 *)(s0 + 0x6) = *(u16 *)(s0 + 0x6) + ((s16)nv[0] >> 6); + *(s16 *)(s0 + 0xA) = *(u16 *)(s0 + 0xA) + ((s16)nv[1] >> 6); + *(s16 *)(s0 + 0xE) = *(u16 *)(s0 + 0xE) + ((s16)nv[2] >> 6); + } + break; + } + ((void (*)(s32))func_8018B9E8)(a0); + } +} + + + +extern void func_8012B1B4(s32 a0, s32 a1); +extern void func_8012CBCC(s32 a0); +extern void func_8012BE98(s32 a0, u16 *a1); +extern void func_8012BE54(s32 a0); +extern s32 func_8012B744(void *a0, void *a1); +extern s32 func_8012B608(s32 a0, s32 a1, s32 a2); +extern s32 func_8018B8B0(s32 a0, s32 a1); + +void func_8018BF50(s32 a0) +{ + s16 hi; + s16 pos; + s32 sp10[3]; + u16 state; + + hi = *(s16 *)(a0 + 0x8A); + pos = *(s16 *)(a0 + 0xA); + + if (pos >= hi - 8) { + if (*(s32 *)(a0 + 0x48) >= 0) { + *(s32 *)(a0 + 0x48) = -0x8000; + *(s32 *)(a0 + 0x14) = *(s32 *)(a0 + 0x14) >> 1; + } + } else { + if (hi + 8 >= pos) { + if (*(s32 *)(a0 + 0x48) <= 0) { + *(s32 *)(a0 + 0x48) = 0x8000; + *(s32 *)(a0 + 0x14) = *(s32 *)(a0 + 0x14) >> 1; + } + } + } + + if (*(s32 *)(a0 + 0xDC) < -0x40000) { + *(s32 *)(a0 + 0xDC) = -0x40000; + } + + sp10[0] = 0; + sp10[1] = 0; + sp10[2] = *(s32 *)(a0 + 0xDC); + func_8012B1B4(a0, (s32)sp10); + func_8012CBCC(a0); + + state = *(u16 *)(a0 + 0x34); + switch (state) { + case 0: { + register s32 s0v __asm__("$16"); // !FAKE: pin $16 — NEEDED DIFFERS (P36 rung B tus9) + s32 ret; + s32 p744; + s32 v1p; + s16 snd; + s32 b608; + register s32 p20 __asm__("$4"); // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + + s0v = a0 + 0x88; + ret = ((s32 (*)(s32, u16 *))func_8012BE98)(a0, (u16 *)s0v); + if (ret <= 0x3FFFF) { + if (func_8018B8B0(a0, 0x51) == 0) { + goto set_state1; + } + } + p744 = func_8012B744((void *)(a0 + 4), (void *)s0v); + v1p = *(s32 *)(a0 + 0x20); + snd = *(s16 *)(v1p + 0x12); + b608 = func_8012B608(snd, p744, 8); + p20 = *(s32 *)(a0 + 0x20); + *(u16 *)(p20 + 0x12) = *(u16 *)(p20 + 0x12) + b608; + v1p = *(s32 *)(a0 + 0x20); + *(u16 *)(v1p + 0x12) = *(u16 *)(v1p + 0x12) & 0xFFF; + func_8012B1B4(a0, (s32)sp10); + break; + } + case 1: { + s32 ret; + + *(s32 *)(a0 + 0xDC) = *(s32 *)(a0 + 0xDC) << 1; + ret = ((s32 (*)(s32, u16 *))func_8012BE98)(a0, (u16 *)(a0 + 0x88)); + if (ret > 0x3FFFF) { + goto rand_tail; + } + if (func_8018B8B0(a0, 0x51) == 0) { + goto end_switch; + } + goto rand_tail; + } + case 2: { + s32 p744; + s32 v1p; + s16 snd; + s32 b608; + s32 p20; + + p744 = func_8012B744((void *)(a0 + 4), (void *)(a0 + 0x88)); + v1p = *(s32 *)(a0 + 0x20); + snd = *(s16 *)(v1p + 0x12); + b608 = func_8012B608(snd, p744, 0x10); + p20 = *(s32 *)(a0 + 0x20); + *(u16 *)(p20 + 0x12) = *(u16 *)(p20 + 0x12) + b608; + v1p = *(s32 *)(a0 + 0x20); + *(u16 *)(v1p + 0x12) = *(u16 *)(v1p + 0x12) & 0xFFF; + *(s32 *)(a0 + 0xDC) = *(s32 *)(a0 + 0xDC) >> 1; + func_8018B8B0(a0, 0x51); + if (*(s16 *)(a0 + 0x102) == 0) { + *(u16 *)(a0 + 0x34) = 3; + } else { + *(s16 *)(a0 + 0x102) = *(s16 *)(a0 + 0x102) - 1; + } + break; + } + case 3: { + s32 s2v; + s32 ret; + s32 p744; + s32 v1p; + s16 snd; + s32 b608; + + s2v = a0 + 0x88; + ret = ((s32 (*)(s32, u16 *))func_8012BE98)(a0, (u16 *)s2v); + *(s32 *)(a0 + 0xDC) = *(s32 *)(a0 + 0xDC) << 1; + if (func_8018B8B0(a0, 0x51) != 0) { + goto rand_tail; + } + if (ret <= 0x40000) { + goto set_state1; + } + p744 = func_8012B744((void *)(a0 + 4), (void *)s2v); + v1p = *(s32 *)(a0 + 0x20); + snd = *(s16 *)(v1p + 0x12); + b608 = func_8012B608(snd, p744, 1); + if ((u32)(b608 + 0xFF) < 0x1FF) { + goto end_switch; + } + goto rand_tail; + } + } + goto end_switch; + +rand_tail: + *(u16 *)(a0 + 0x34) = 2; + { + s32 r = rand(); + *(s16 *)(a0 + 0x102) = (r & 7) + 8; + } + goto end_switch; + +set_state1: + *(u16 *)(a0 + 0x34) = 1; + +end_switch: + if (*(s16 *)(a0 + 0x100) != 0) { + *(s16 *)(a0 + 0x100) = *(s16 *)(a0 + 0x100) - 1; + } else { + s32 ret3; + + ret3 = ((s32 (*)(s32))func_8012BE54)(a0); + if (ret3 <= 0x24000) { + *(s16 *)(a0 + 0x2) = 2; + *(s16 *)(a0 + 0x100) = 0x3C; + } + } +} + + + + +extern s32 func_80188204(s32 a0, s32 a1); +extern s32 func_8012C588(s32 a0, s32 a1); +extern void func_8012F14C(s32 a0, s32 a1, s32 a2); +extern void func_8012B370(int a0); +extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2); +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); + + +void func_8018C28C(s32 param_1) +{ + + extern u8 D_801DD650; + extern u8 D_801DD658; + extern u8 D_801DD660; + extern u8 D_800AF648; + /* L5: slot offsets are exact only through ONE struct — copied verbatim + from the banked RTP_SND sibling func_80180CA8 (same TU) so the + sp+0x10.."0x2B layout reproduces byte-for-byte. */ + struct { + u16 nv[4]; /* sp+0x10 */ + s16 rv[4]; /* sp+0x18 */ + u16 sxy[2]; /* sp+0x20 */ + s32 z; /* sp+0x24 */ + s32 flag; /* sp+0x28 */ + } L; + + s16 sVar1; + s32 s0; + + if (*(s32 *)(param_1 + 0x1c) == 0) { + sVar1 = *(s16 *)(param_1 + 0x100) - 1; + *(s16 *)(param_1 + 0x100) = sVar1; + if (sVar1 == 0) { + *(s16 *)(param_1 + 2) = 1; + *(s16 *)(param_1 + 0x100) = 0x3c; + *(s16 *)(param_1 + 0x8a) = *(s16 *)(param_1 + 0xa) - 0x140; + } else { + *(s32 *)(param_1 + 0x1c) = (sVar1 == 1) ? 0x3c : 3; + + func_80188204(param_1, (s32)&D_801DD650); + + s0 = func_8012C588(0x260, param_1); + if (s0 != 0) { + ((void (*)(s32, s32, s32))func_8012F14C)(*(s32 *)(param_1 + 0x20) + 0x34, (s32)&D_801DD658, (s32)L.nv); + *(s16 *)(s0 + 6) = L.nv[0]; + *(s16 *)(s0 + 0xA) = L.nv[1]; + *(s16 *)(s0 + 0xE) = L.nv[2]; + func_8012B370(s0); + func_8012C658(0x261, 0, s0); + } + + s0 = func_8012C588(0x260, param_1); + if (s0 != 0) { + ((void (*)(s32, s32, s32))func_8012F14C)(*(s32 *)(param_1 + 0x20) + 0x34, (s32)&D_801DD660, (s32)L.nv); + *(s16 *)(s0 + 6) = L.nv[0]; + *(s16 *)(s0 + 0xA) = L.nv[1]; + *(s16 *)(s0 + 0xE) = L.nv[2]; + func_8012B370(s0); + func_8012C658(0x261, 1, s0); + } + + L.rv[0] = *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x48); + L.rv[1] = *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x4C); + L.rv[2] = *(s32 *)(*(s32 *)(param_1 + 0x20) + 0x50); + { register void *r4 __asm__("$4"); r4 = &D_800AF648; func_8004914C(r4); } // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus9) + { void *r4; r4 = &D_800AF648; func_800491AC(r4); } + RotTransPers((s32)L.rv, (s32)L.sxy, &L.z, &L.flag); + if (L.flag >= 0 && (u32)((L.sxy[0] + 0xEF) & 0xFFFF) < 0x1DF + && (u32)((L.sxy[1] + 0xB3) & 0xFFFF) < 0x167) { + s32 x = (s16)L.sxy[0]; + s32 ax; + + ax = x; + if (x < 0) { + ax = -x; + } + ax = ((0xF0 - ax) * 0x7F) / 0xF0; + x = (x + 0xF0) / 0x1E; + if (x == 0x10) { + x = 0xF; + } + x = x << 8; + { + s32 flg = 0x3000; + func_8002D4C8(0x84A, ((ax | flg) | x) & 0xFFFF); + } + } + } + } else { + *(s32 *)(param_1 + 0x1c) = *(s32 *)(param_1 + 0x1c) - 1; + } +} + + +typedef struct { + SVECTOR_8016E7C8 v[4]; /* 0x00 */ + s32 f0, f1, f2, f3, f4, f5; /* 0x20..0x37 */ + u8 f6; /* 0x38 */ + u8 pad[7]; /* -> 0x40 */ +} Prim_8016E7C8_8018C534; + + + + + + + + + +void func_8018C534(s32 a0) +{ + + extern s16 D_801DD668[]; + extern u16 D_80126B5E; + extern u16 D_80126B62; + extern u16 D_80126B66; + switch (*(u16 *)(a0 + 0x34)) { + case 0: + { + s16 idx = *(s16 *)(a0 + 0x70); + s16 *p = &D_801DD668[(idx - 1) * 4]; + s16 gx = *(s16 *)&D_80126B5E; + s16 gz; + s32 p20; + + if (!(*p < gx)) { + break; + } + p++; + if (!(gx < *p)) { + break; + } + p++; + gz = *(s16 *)&D_80126B66; + if (!(*p < gz)) { + break; + } + if (!(gz < p[1])) { + break; + } + + p20 = *(s32 *)(a0 + 0x20); + *(u32 *)(p20 + 4) = *(u32 *)(p20 + 4) & 0x7FFFFFFF; + + { + s32 t; + + *(s16 *)(a0 + 0x88) = D_80126B5E; + *(s16 *)(a0 + 0x6) = D_80126B5E; + t = D_80126B62 - 0x80; + *(s16 *)(a0 + 0x8A) = t; + + t = *(u16 *)(a0 + 0x34); + { + s16 z; + z = D_80126B66; + *(u16 *)(a0 + 0x34) = (t + 1); + *(s16 *)(a0 + 0x8C) = z; + *(s16 *)(a0 + 0xE) = z; + } + } + break; + } + case 1: + { + s16 v; + + v = *(u16 *)(a0 + 0xA) + 8; + *(u16 *)(a0 + 0xA) = v; + if (v < *(s16 *)(a0 + 0x8A)) { + break; + } + *(s16 *)(a0 + 0x2) = 1; + *(u16 *)(a0 + 0x34) = 0; + break; + } + } +} + + +extern s32 D_801DD688[]; +extern s32 func_8012C044(s32 a0); +extern void func_80016714(void *a0, s32 a1); +extern void func_8012C098(void *a0); +extern void func_8018BBBC(void); + +void func_8018C664(s32 a0) +{ + void (*handler)(s32); + + handler = (void (*)(s32))D_801DD688[*(u16 *)(a0 + 0x2)]; + handler(a0); + + if (*(u16 *)(a0 + 0x0) == 0) + return; + + ((void (*)(s32))func_8018BBBC)(a0); + + if (func_8012C044(a0) == 0) + return; + + if (*(s16 *)(a0 + 0x70) == 0) { + if (*(s32 *)(a0 + 0xCC) != 0) + func_80016714(*(void **)(a0 + 0xCC), 0x84); + if (*(s32 *)(a0 + 0xD0) != 0) + func_80016714(*(void **)(a0 + 0xD0), 0x84); + func_8012C098((void *)a0); + } else { + if (*(u16 *)(a0 + 0x2) < 4) + *(u16 *)(a0 + 0x2) = 4; + } +} + + + +extern void (*D_801DD6B4[])(void); + +void func_8018C73C(void *a0) { + D_801DD6B4[*(u16 *)((s32)a0 + 0x2)](); +} + + + +/* SV4 is the TU-canonical name (src/shared/engine_types.h) for func_8012F214's + * in/out struct (see ov_SC06_008_jr_8017AE2C.c:3135, "SV4 svec" comment: func_8012F214 out). + * Isolated match_one has no include path to that header, so it is typedef'd + * locally here for the standalone compile only. */ + + +/* func_8018C778 - ov_SC06_008 / ov_SC06_008_jr_8017C294 (93 ins) + * + * One-time init (guarded by state flag at +0x34): mirror the +0x64 sub-object's + * +0x20/+0x12 field into our own +0x20 sub-object, kick off two "core" calls, + * pick an entry from the 2-element 12-byte table D_801DD6BC (indexed by the + * s16 at +0x70), then call func_8012F214 with a zeroed input SV4 and read the + * first 3 fields of the output SV4 back into +6/+0xA/+0xE. Sets the countdown + * at +0x1c to 0x5a and marks the state flag +0x34 = 1. + * + * Always-executed tail: bump the +0x20 sub-object's +0x10/+0x12/+0x14 fields + * (reloading the +0x20 pointer fresh for each field -- no CSE across the + * intervening stores, straight literal translation), mirror +0x14 into +0xDC, + * call func_8012CBCC(a0) and test its return (canonical fleet decl is + * void func_8012CBCC(s32 a0); the return value is read via a function- + * pointer cast at the use site, per the established TU idiom -- see + * ov_SC03_099_jr_8017BEBC.c:5630 comment block). If (ret & 0x6000), decrement + * the +0xac counter (signed s16 compare-to-zero on the POST-decrement value -- + * gcc-2.7.2's sll-by-16/bnez idiom for a s16 local) and negate +0xDC into + * +0x14; on the counter hitting zero, call func_8012C218. Finally decrement + * the +0x1c countdown and call func_8012C218 again when IT hits zero. + */ + +extern void func_8012B2CC(s32 a0); +extern void func_8012B23C(s32 a0); +extern void func_8012B14C(s32 a0, s32 a1); +extern void func_8012F214(s32 a0, s32 a1, s32 a2); +extern void func_8012CBCC(s32 a0); +extern void func_8012C218(void *a0); + + +void func_8018C778(s32 a0) +{ + + extern s32 D_801DD6BC; + SV4 in; + SV4 out; + s16 v1; + u16 uStack_c; + + if (*(u16 *)(a0 + 0x34) == 0) { + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x12); + func_8012B2CC(a0); + func_8012B23C(a0); + func_8012B14C(a0, *(s16 *)(a0 + 0x70) * 12 + (s32)&D_801DD6BC); + + in.a = 0; + in.b = 0; + in.c = 0x10; + func_8012F214(a0, (s32)&in, (s32)&out); + *(u16 *)(a0 + 6) = out.a; + *(u16 *)(a0 + 0xa) = out.b; + uStack_c = out.c; + *(s32 *)(a0 + 0x1c) = 0x5a; + *(u16 *)(a0 + 0x34) = 1; + *(u16 *)(a0 + 0xe) = uStack_c; + } + + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) += -0x80; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) += 4; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) += *(u16 *)(a0 + 0xfc); + + *(s32 *)(a0 + 0xdc) = *(s32 *)(a0 + 0x14); + if ((((s32 (*)(s32))func_8012CBCC)(a0)) & 0x6000) { + register s32 negdc __asm__("$2"); // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus9) + negdc = -*(s32 *)(a0 + 0xdc); + v1 = *(u16 *)(a0 + 0xac); + v1 -= 1; + *(s16 *)(a0 + 0xac) = v1; + *(s32 *)(a0 + 0x14) = negdc; + if (v1 == 0) { + func_8012C218((void *)a0); + } + } + + { + s32 iVar3 = *(s32 *)(a0 + 0x1c) - 1; + *(s32 *)(a0 + 0x1c) = iVar3; + if (iVar3 == 0) { + func_8012C218((void *)a0); + } + } +} + + + +extern void (*D_801DD6D4[])(void); + +void func_8018C8EC(void *a0) { + D_801DD6D4[*(u16 *)((s32)a0 + 0x2)](); +} + + +extern void func_80016714(void *a0, s32 a1); +extern void func_8002A04C(s32 a0); +extern void func_8012C218(void *a0); + +void func_8018C928(a0) +s32 a0; +{ + if (*(s16 *)(a0 + 0x70) != 0) { + *(u16 *)(a0 + 0x2) = 4; + *(u16 *)(a0 + 0x5C) = 0; + *(u16 *)(a0 + 0x5E) = 0; + *(u8 *)(a0 + 0xC1) = 0; + return; + } + + if (*(s32 *)(a0 + 0xCC) != 0) + func_80016714(*(void **)(a0 + 0xCC), 0x84); + + if (*(s32 *)(a0 + 0xD0) != 0) + func_80016714(*(void **)(a0 + 0xD0), 0x84); + + func_8002A04C(a0); + func_8012C218((void *)a0); +} + + + +extern void func_8002D4C8(s32 arg0, s32 arg1); +extern void func_8018B9E8(void); + +void func_8018C9B0(void *a0) { + func_8002D4C8(0xB32, 0); + ((void (*)(void *))func_8018B9E8)(a0); +} + + +extern void func_8018BBBC(void); + void func_8018C9E8(s32 *param_1) { + *(short *)(*(int *)((char *)param_1 + 0x20) + 0x10) = 0xe00; + ((void (*)(void))func_8018BBBC)(); + } + + + + +extern void func_8018BBBC(void); + void func_8018CA10(s32 arg0) { + s32 temp_v1 = *(s32 *)(arg0 + 0x20); + *(s16 *)(temp_v1 + 0x10) += 0x20; + ((void (*)(void))func_8018BBBC)(); + } + + +extern void func_80131E00(); +extern void func_8018BBBC(void); + +void func_8018CA44(a0) +s32 a0; +{ + if (*(s16 *)(a0 + 0x76) < 0) { + func_80131E00(a0, 6); + } else { + *(s16 *)(a0 + 2) = 1; + *(s16 *)(a0 + 0x100) = 0x3C; + *(u16 *)(a0 + 0x34) = 0; + func_8018BBBC(); + } +} + + + +extern int func_80143C74(short*, int); +extern s32 rand(void); +extern void func_8018BBBC(void); + +void func_8018CA90(s32 a0) +{ + s32 s0; + + if (*(u16 *)(a0 + 0x0) != 0) { + s0 = ((s32 (*)(s32, s32))func_80143C74)(a0, 0); + if (s0 != 0) { + *(u16 *)(s0 + 0x6) = *(u16 *)(a0 + 0x6) + (rand() & 0x3F) - 0x20; + *(u16 *)(s0 + 0xA) = *(u16 *)(a0 + 0xA) + (rand() & 0x3F) - 0x30; + *(u16 *)(s0 + 0xE) = *(u16 *)(a0 + 0xE) + (rand() & 0x3F) - 0x20; + *(s32 *)(s0 + 0x10) = -*(s32 *)(a0 + 0x10); + *(s32 *)(s0 + 0x14) = -*(s32 *)(a0 + 0x14); + *(s32 *)(s0 + 0x18) = -*(s32 *)(a0 + 0x18); + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x18) = 0x800; + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x1A) = 0x800; + } + ((void (*)(s32))func_8018BBBC)(a0); + } +} + + +extern void func_8018B9E8(void); + void func_8018CB7C(s32 *a0) { + *(s32 *)((s32)a0 + 0x10) = *(s32 *)((s32)a0 + 0x10) >> 1; + *(s32 *)((s32)a0 + 0x18) = *(s32 *)((s32)a0 + 0x18) >> 1; + ((void (*)(void))func_8018B9E8)(); + } + + + + +extern void func_8018B9E8(void); + void func_8018CBB0(s32 a0) { + s32 v0; + v0 = 0xc; + *(s8 *)(a0 + 0xc1) = v0; + *(s32 *)(a0 + 0x1c) = 0x3c; + ((void (*)(void))func_8018B9E8)(); + } + + +extern void func_801319E0(s32 a0); +extern s32 func_8012BEE8(s32 a0); +extern s32 func_8012CBF4(s32 a0); +extern void func_80131E00(s32 a0, s32 a1); +extern void func_80131C78(s32 a0); +extern void func_8018B9E8(void); + +void func_8018CBDC(s32 a0) { + if (*(s16 *)(a0 + 0xA) >= 0x10) { + func_801319E0(a0); + } else { + if (func_8012BEE8(a0) != 0) { + func_80131E00(a0, 6); + } else { + if (func_8012CBF4(a0) & 0x2000) { + func_80131C78(a0); + } + ((void (*)(s32))func_8018B9E8)(a0); + } + } +} + + + +extern s32 func_8012C354(s32 a0, s32 a1); +extern void func_80143970(); +extern void func_8012A828(s32 a0, void *a1); +extern void func_8012B200(u8 *a0); +extern void func_8012C1B8(void); +extern void func_8001C214(s32 a0, s32 a1); +extern void func_80016714(void *a0, s32 a1); +extern void func_8012CAE4(void *a0); + +void func_8018CC68(s32 a0) { + + extern u8 D_801DD554[]; + extern u8 D_801DF294[]; + extern u8 D_801DD588[]; + extern u8 D_801DEFA4[]; + extern u8 D_801DF27C[]; + extern u8 D_8018D644[]; + + s32 s0; + u16 t; + + if (func_8012C354(a0, D_801DD554) == 0) { + return; + } + *(u8 *)(a0 + 0xC0) = 1; + *(s32 *)(a0 + 0xB4) = -0x1001; + ((s32 (*)(s32))func_80143970)(a0); + func_8012A828(a0, D_801DF294); + *(u16 *)(a0 + 0x2) += 1; + func_8012B200((u8 *)a0); + *(s32 *)(a0 + 0xBC) = (s32)D_801DD588; + + s0 = ((s32 (*)(void))func_8012C1B8)(); + if (s0 == 0) { + goto fail; + } + *(s32 *)(a0 + 0xCC) = s0; + func_8001C214(s0, (s32)D_801DEFA4); + t = *(u16 *)(s0 + 0x2C) | 0x10; + *(s32 *)(s0 + 0x20) = *(s32 *)D_8018D644; + *(u16 *)(s0 + 0x2C) = t; + + s0 = ((s32 (*)(void))func_8012C1B8)(); + if (s0 == 0) { + func_80016714((void *)*(s32 *)(a0 + 0xCC), 0x84); +fail: + func_8012CAE4((void *)a0); + return; + } + *(s32 *)(a0 + 0xD0) = s0; + func_8001C214(s0, (s32)D_801DF27C); + t = *(u16 *)(s0 + 0x2C) | 0x10; + *(s32 *)(s0 + 0x20) = *(s32 *)D_8018D644; + *(u16 *)(s0 + 0x2C) = t; + *(u16 *)(a0 + 0x100) = 0x3C; + *(s32 *)(a0 + 0xDC) = 0xFFFC0000; +} + + + + +extern void func_8012B1B4(s32 a0, s32 a1); +extern void func_8012CBCC(s32 a0); +extern s32 func_8018B8B0(s32 a0, s32 a1); +extern s32 func_8012B8E4(s32 arg0, s32 arg1); + +void func_8018CD90(s32 a0) +{ + + extern s32 D_80126B60; + s32 sp10[3]; + + if (*(s32 *)(a0 + 8) >= D_80126B60 - 0x200000) { + if (*(s32 *)(a0 + 0x48) >= 0) { + *(s32 *)(a0 + 0x48) = -0x8000; + *(s32 *)(a0 + 0x14) = *(s32 *)(a0 + 0x14) >> 1; + } + } else { + if (D_80126B60 - 0x180000 >= *(s32 *)(a0 + 8)) { + if (*(s32 *)(a0 + 0x48) <= 0) { + *(s32 *)(a0 + 0x48) = 0x8000; + *(s32 *)(a0 + 0x14) = *(s32 *)(a0 + 0x14) >> 1; + } + } + } + + *(s32 *)(a0 + 0xDC) = *(s32 *)(a0 + 0xDC) >> 1; + + sp10[0] = 0; + sp10[1] = 0; + sp10[2] = *(s32 *)(a0 + 0xDC); + func_8012B1B4(a0, (s32)sp10); + func_8012CBCC(a0); + func_8018B8B0(a0, 0x51); + + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) += func_8012B8E4(a0, 0x10); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) &= 0xFFF; + + *(u16 *)(a0 + 0x100) -= 1; + if (*(s16 *)(a0 + 0x100) == 0) { + *(s16 *)(a0 + 2) = 3; + *(u16 *)(a0 + 0x100) = 5; + *(s32 *)(a0 + 0x1C) = 0; + } +} + + + + +void func_8018CEC4(s32 a0) { + s32 p; + s32 q; + + p = *(s32 *)(a0 + 0x20); + *(u16 *)(a0 + 0x6) = 0x7FFF; + *(s16 *)(a0 + 0xA) = -0x1000; + *(u16 *)(a0 + 0x2) = 5; + *(u16 *)(a0 + 0x34) = 0; + *(s32 *)(a0 + 0x1C) = 0x12C; + *(s32 *)(p + 0x4) |= 0x80000000; + q = *(s32 *)(a0 + 0x20); + *(u16 *)(q + 0x1C) = 0x1000; + *(u16 *)(q + 0x1A) = 0x1000; + *(u16 *)(q + 0x18) = 0x1000; + *(u16 *)(a0 + 0x76) = 0x1E0; + *(u16 *)(a0 + 0x5C) = 0x8810; +} + + +void func_8018CF24(s32 a0) +{ + extern void func_8012C1B8(void); + extern void func_8012CAE4(void *a0); + extern void func_8001C214(s32 a0, s32 a1); + extern void func_8012A828(s32 a0, void *a1); + extern u8 D_801DF374[]; + extern u8 D_8018D644[]; + + s32 v0; + + v0 = ((s32 (*)(void))func_8012C1B8)(); + *(s32 *)(a0 + 0x20) = v0; + if (v0 == 0) { + func_8012CAE4((void *)a0); + } else { + func_8001C214(v0, (s32)D_801DF374); + func_8012A828(a0, (void *)D_8018D644); + *(u16 *)(a0 + 0x2) = 1; + *(s32 *)(a0 + 0x1C) = 0x40; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x10) = + *(u16 *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x10); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x12); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x14) = + *(u16 *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x14); + } +} + + +extern u8 D_801DD6A0[]; +extern u8 D_801DD6AC[]; +extern u8 D_800D3918[]; +extern void func_8012B14C(s32 a0, s32 a1); +extern void func_8012AD80(s32 a0); +extern void func_8012B370(s32 a0); + +void func_8018CFE4(void *param_1) { + s32 v0; + + if ((*(s16 *)((s32)param_1 + 6) == *(s16 *)((s32)param_1 + 0xDE)) && + (*(s16 *)((s32)param_1 + 0xE) == *(s16 *)((s32)param_1 + 0xE2))) { + func_8012C218(param_1); + return; + } + + *(s32 *)((s32)param_1 + 0xDC) = *(s32 *)((s32)param_1 + 4); + *(s32 *)((s32)param_1 + 0xE0) = *(s32 *)((s32)param_1 + 0xC); + func_8012B14C((s32)param_1, (s32)&D_801DD6A0); + func_8012AD80((s32)param_1); + + v0 = func_8012D5E4((s32)param_1, (s32)&D_801DD6AC, (s32)&D_800D3918, 0x30); + if (v0 != 0) { + func_8012C218(param_1); + return; + } + + v0 = *(s32 *)((s32)param_1 + 0x1C); + v0 = v0 - 1; + *(s32 *)((s32)param_1 + 0x1C) = v0; + if (v0 == 0) { + func_8012C218(param_1); + } else { + func_8012B370((s32)param_1); + } +} + + + +extern void func_8012C1B8(void); +extern void func_8001C214(s32 a0, s32 a1); +extern void func_8012CAE4(void *a0); +extern s32 func_80047948(s32 a0); +extern s32 func_8004787C(s32 a0); +extern s32 rand(void); + +void func_8018D0B8(s32 param_1) +{ + + extern u8 D_801DF434[]; + *(s32 *)(param_1 + 0x20) = ((s32 (*)(void))func_8012C1B8)(); + if (*(s32 *)(param_1 + 0x20) == 0) { + func_8012CAE4((void *)param_1); + } else { + func_8001C214(*(s32 *)(param_1 + 0x20), (s32)D_801DF434); + + *(u16 *)(param_1 + 0x2) = 1; + *(u16 *)(param_1 + 0x34) = 0; + { + s32 v1 = *(s32 *)(param_1 + 0x64); + s32 t = *(s32 *)(v1 + 0x20); + s32 r = func_80047948(*(s16 *)(t + 0x12)); + *(s32 *)(param_1 + 0xC) = *(s32 *)(param_1 + 0xC) + (r << 8); + } + { + s32 v1 = *(s32 *)(param_1 + 0x64); + s32 t = *(s32 *)(v1 + 0x20); + s32 r = func_8004787C(*(s16 *)(t + 0x12)); + *(s32 *)(param_1 + 0x4) = *(s32 *)(param_1 + 0x4) + (r << 8); + } + { + s32 t = *(s32 *)(param_1 + 0x20); + *(u16 *)(t + 0x2C) = *(u16 *)(t + 0x2C) | 0x10; + } + { + s32 t = *(s32 *)(param_1 + 0x20); + *(s16 *)(t + 0x18) = 0x1800; + } + { + s32 t = *(s32 *)(param_1 + 0x20); + *(s16 *)(t + 0x1A) = 0x1800; + } + { + s32 t = *(s32 *)(param_1 + 0x20); + *(s16 *)(t + 0x1C) = 0x1800; + } + + *(u16 *)(param_1 + 0xAC) = 2; + { + s32 r = rand(); + *(u16 *)(param_1 + 0xFC) = r & 0xFF; + } + } +} + + + +extern void func_8012B23C(s32 a0); +extern void func_8012CBCC(s32 a0); +extern u8 *func_8012913C(s32 a0); +extern void func_8012C218(void *a0); + +void func_8018D1B0(s32 a0) +{ + s32 s0 = a0; + s32 ret; + u16 val; + + if (*(u16 *)(s0 + 2) == 0) { + *(u8 *)(s0 + 0xC0) = 1; + *(u16 *)(s0 + 2) = *(u16 *)(s0 + 2) + 1; + func_8012B23C(s0); + *(s32 *)(s0 + 0x1C) = 1; + return; + } + + *(s32 *)(s0 + 0xDC) = *(s32 *)(s0 + 0x14); + ret = ((s32 (*)(s32))func_8012CBCC)(s0); + if (ret != 0 && (ret & 0x6000) != 0) { + s32 cnt = *(s32 *)(s0 + 0x1C) - 1; + *(s32 *)(s0 + 0x1C) = cnt; + if (cnt == 0) { + goto L80183CF4; + } + *(s32 *)(s0 + 0x14) = -*(s32 *)(s0 + 0xDC) >> 2; + } + + val = *(u16 *)(s0 + 0xFC) + 1; + *(u16 *)(s0 + 0xFC) = val; + if ((val & 1) != 0) { + s32 np = (s32)func_8012913C(0x23); + if (np != 0) { + *(u16 *)(np + 6) = *(u16 *)(s0 + 6); + *(u16 *)(np + 0xA) = *(u16 *)(s0 + 0xA); + { + u16 t = *(u16 *)(s0 + 0xE); + *(u32 *)(np + 0x18) = 0; + *(u32 *)(np + 0x14) = 0; + *(u32 *)(np + 0x10) = 0; + *(u16 *)(np + 0x34) = 0x3000; + *(u16 *)(np + 0xE) = t; + } + } + } + + if (*(s16 *)(s0 + 0xA) < 0x20) { + return; + } + +L80183CF4: + func_8012C218((void *)s0); +} + + + + + + diff --git a/.run/P36/agents/ov_SC06_022__func_80185578/mechanism.md b/.run/P36/agents/ov_SC06_022__func_80185578/mechanism.md new file mode 100644 index 000000000..f7150e0ca --- /dev/null +++ b/.run/P36/agents/ov_SC06_022__func_80185578/mechanism.md @@ -0,0 +1,75 @@ +# func_80185578 (ov_SC06_022, 6 copies): closed lever-free — it returns int, and `y` is an s16 (agent c43, S103) + +**Result: score 0, and the whole object is byte-identical (`objdump -drz -s` diff empty), BUT THE CLOSE NEEDS A CHANGE +OUTSIDE THE BODY.** The function returns a value, so its three in-TU declarations have to say `s32` instead of +`void`: +- `src/ov_SC06_022/ov_SC06_022_jr_80184A28.c:2998` `extern void func_80185578(s32 a0, s32 a1);` → `extern s32 ...` +- `:3288` and `:3289` (the two "SIMULATION of real-TU context" rows right above the definition) → `extern s32 ...` + +`PACK/body.c` is the definition (it gives `conflicting types` under `--body` while those rows still say void). +`PACK/body_tu.c` is the whole TU with the three rows retyped, and scores 0 via `--try` without `--body`. The other two +TUs that declare it (`ov_SC06_022_jr_80184304.c:2978`, `ov_SC06_022_jr_80182D08.c:3605`) are byte-identical either +way (whole-object diffs empty with the rows retyped: `scratch/decl_*.c`), so they can be retyped for consistency or +left alone. Their callers discard the result. + +**Transfer: all 6 copies score 0, and each whole object is byte-identical**, with the same edit plus that TU's own +declarations retyped (`scratch/xfer.py`; 3-4 rows per TU). The copies are ov_SC06_018 func_801874E4, SC06_020 +func_80181654, SC06_022 func_80185578, SC06_024 func_80187A50, SC06_032 func_80182288, SC06_033 func_80185F6C. + +## (a) The residual (counted first: mine 90, target 94) +Two independent defects: +1. **A missing `move s3,s0`** (the `y = x` copy). The target keeps `x` in `$s0`, shared later with `res`, and `y` in + `$s3`. Lever-free, `y` and `x` became ONE pseudo (`move s2,a1`), and every register downstream shifts. The tree's + `addu y, x, $zero` asm faked that copy. +2. **Missing `$v0` writes**: `move v0,zero` on the `flags & 4` path and `li v0,1` on the other paths. The function + RETURNS 0 ("already set up", bit 2 of +0xE0) or 1. The tree declared it `void` and faked the return value with a + keepalive asm `"r"(rv)` after an `epi:` label. + +## (b) The passes (proved on dumps: `scratch/dumps_r6/` vs `scratch/dumps_r6s/`) +1. The copy: with `s32 y`, `.rtl` insn 13 is `(set (reg:SI 74) (reg:SI 73))`, and cse1's `(set REG0 REG1)` case + (cse.c:7440-7474, gate :7455 wants a REG source) retargets the previous insn: `.cse` insn 6 becomes + `(set (reg 74) (reg:SI 5 a1))` and the copy disappears. With `s16 y`, the insn is + `(set (reg:HI 74) (subreg:HI (reg:SI 73) 0))`. Its source is a SUBREG, not a REG, so the gate fails and the copy + survives cse (`.cse` insn 13, `movhi_internal2`). It's a separate pseudo, so it gets `$s3` while `arg1` keeps + `$s0` and dies into the case-0 call. This is METHOD c4's width mechanism exactly: there's no PROMOTE_MODE, so the + s16 local is an HImode pseudo. +2. The return value: `return 0` / `return 1` on an `s32` function sets `$2` on every path, which a void function + can't do. No pass is involved; the bytes just prove the function has a return value. + +What's proved on bytes: `r1` (s32 return, s32 y) = 16 [COUNT, 93 vs 94], which is the copy alone. +`r2`/`r3`/`r5`/`r6` (s32 return plus u16/s16 y, in several spellings) = 0. `r6s` (r6 with `s32 y`) = 16. +`r7` (no `y`, `arg1` used directly) = 16. history.txt's `y s32->u16` alone = 11, which is the width without the +return value. + +## (c) The moves (a JOINT close; neither alone reaches 0) +- `void` → `s32`, with `return 0;` / `return 1;` in place of `rv = …; goto epi;` (plus the declarations above). +- `s16 y = arg1;` replaces `s32 x = arg1; s32 y; y = x;`, and case 0 passes `(s16)arg1`. `x` goes away entirely: + the parameter IS `x`. + +## (d) GENERATOR PROPOSAL +Two rules. (1) **When a `void` function's tree body ends in a keepalive `__asm__ volatile("" : : "r"(v))` on a +0/1 (or constant) variable assigned before gotos to the end label, the function returns that value.** Retype the +definition and every in-TU `extern void` row to `s32`, turn `v = K; goto end;` into `return K;`, and score the +WHOLE TU (`--try` without `--body`). Callers that discard the result don't change bytes (checked in 2 TUs here). +Sizing grep: `grep -rn '__asm__ volatile("" : : "r"(rv))' src` = 6 (exactly this class). The wider +`grep -rn '__asm__ volatile("" : : "r"(' src | grep keepalive` = 19; not every one of those is a return value, so +check each target for `$v0` writes before the epilogue. (2) When a `y = x` copy of a parameter is +missing and `y` is only used under a `(s16)`/`(u16)` cast, declare `y` s16/u16 (R20) — AFTER rule 1, because a +missing return value adds COUNT noise that hides whether the width move worked (history's `y->u16` scored 11 and +the search stopped there). + +## (e) Tried and did not work (bytes) +- Every body-only variant: the return value can't be produced in a void function without a lever. I didn't try a + `volatile` or asm. +- `r1`: s32 return with `s32 y` = 16. `r7`: drop `y` = 16. Both lose the copy (the cse.c:7455 swap). + +## (f) Where the method fell short +- Counting first found it straight away: 4 missing = 1 copy + 3 `$v0` writes. But the brief's goal ("no change + outside the body") is unreachable for any function the decomp mis-declared as `void`, and the `--body` scorer + can't express the fix at all: it compiles `conflicting types`. The mechanical search (history.txt) ran 1,127 + compiles on body-only moves that could never have reached 0. +- METHOD has no row for "keepalive asm = a missing return value". It should come FIRST in the COUNT branch: the + `$v0` writes are the cheapest instructions to account for, and one look at the target (`move v0,zero` in a `j` + delay slot, `li v0,1` before the epilogue) settles it. +- The tree's rows at `:3287-3289` ("SIMULATION of real-TU context") are two duplicate `extern void` declarations. + They are the lines that have to change, and the sibling TUs carry 3-4 such rows each. diff --git a/.run/P36/census/lever_census.json b/.run/P36/census/lever_census.json index 130f03bc0..fb10b9a9a 100644 --- a/.run/P36/census/lever_census.json +++ b/.run/P36/census/lever_census.json @@ -54,7 +54,7 @@ }, "kinds": { "asm-body/direct": 13, - "barrier/direct": 1934, + "barrier/direct": 1929, "barrier/via-macro": 2, "gte-lever/direct": 362, "gte-lever/via-macro": 100, @@ -72,26 +72,26 @@ "binaries": 218, "classes": { "A": { - "bodies": 2334, - "distinct_bodies": 869, + "bodies": 2329, + "distinct_bodies": 868, "file_scope": 0, - "in_bodies": 6910, + "in_bodies": 6900, "kinds": { - "pin": 6910 + "pin": 6900 }, - "marked": 6910, - "sites": 6910, + "marked": 6900, + "sites": 6900, "tus": 1416, "unmarked": 0 }, "B": { - "bodies": 5024, - "distinct_bodies": 857, + "bodies": 5019, + "distinct_bodies": 856, "file_scope": 13, - "in_bodies": 14623, + "in_bodies": 14618, "kinds": { "asm-body": 13, - "barrier": 1936, + "barrier": 1931, "gte": 6858, "gte-lever": 462, "gte-unsigned": 3, @@ -100,9 +100,9 @@ "launder": 1801, "verbatim-body": 2682 }, - "marked": 5359, - "sites": 14636, - "tus": 1599, + "marked": 5354, + "sites": 14631, + "tus": 1596, "unmarked": 9277 }, "C": { @@ -207,9 +207,9 @@ "coverage": { "asm": { "comment_dead": 6786, - "live": 22548, + "live": 22533, "macro_block": 194, - "raw": 29528 + "raw": 29513 }, "attribute": { "comment_dead": 0, @@ -225,9 +225,9 @@ }, "register": { "comment_dead": 8565, - "live": 6960, + "live": 6950, "macro_block": 18, - "raw": 15543 + "raw": 15533 }, "volatile": { "comment_dead": 2476, @@ -237,7 +237,7 @@ } }, "coverage_ok": true, - "elapsed_s": 29.7, + "elapsed_s": 31.0, "generated": "2026-09-10", "gte_levers": { "direct": 362, @@ -248,15 +248,15 @@ "via_macro": 100, "what": "GTE ops whose clobbers exceed the canonical macro's (a scheduling steer): class-B levers INSIDE the headline number since T5 (2026-09-09), marked, 0 at the close" }, - "head": "321b540e7", + "head": "2a4f28f83", "headers": 3181, "levers_AB": { - "asm": 5093, - "bodies": 3060, - "distinct_bodies": 1160, - "marked": 12003, - "pins": 6910, - "sites": 12003, + "asm": 5088, + "bodies": 3050, + "distinct_bodies": 1158, + "marked": 11988, + "pins": 6900, + "sites": 11988, "unmarked": 0, "what": "register pins + asm statements excluding GTE ops: the classes the phase drives to 0" }, @@ -412,7 +412,7 @@ "$29": 13, "$3": 698, "$4": 1045, - "$5": 969, + "$5": 959, "$6": 212, "$7": 175, "$8": 170, @@ -423,30 +423,30 @@ "v0": 2, "v1": 3 }, - "sites": 6910, + "sites": 6900, "sp": 13, "spelling": { - "__asm__": 6853, + "__asm__": 6843, "asm": 57 }, "volatile_qualified": 3, "zero": 106 }, - "src_stamp": "7552158a131a0fab", + "src_stamp": "43d7810b6d23cc55", "tus": 4121, "unclassified": 0, "union_AD": { - "bodies": 6586, + "bodies": 6576, "by_kind": { "main": 165, "md": 133, - "ov": 6097, + "ov": 6087, "resident": 10, "shared": 181 }, - "copies_in_multi": 5351, - "distinct_bodies": 1450, - "multi_copy_classes": 215 + "copies_in_multi": 5341, + "distinct_bodies": 1448, + "multi_copy_classes": 213 }, "verbatim_excluded": { "functions": 13, diff --git a/.run/P36/census/lever_census.txt b/.run/P36/census/lever_census.txt index d0fe344f2..ec9bc6d7a 100644 --- a/.run/P36/census/lever_census.txt +++ b/.run/P36/census/lever_census.txt @@ -1,31 +1,31 @@ lever_census: 218 binaries · 4,121 TUs + 3,181 headers · coverage OK · unclassified 0 · verbatim excluded 13 fn / 14 sites (manifest 13) - coverage asm raw 29528 = live 22548 + macro-block 194 + comment/dead 6786 - coverage register raw 15543 = live 6960 + macro-block 18 + comment/dead 8565 + coverage asm raw 29513 = live 22533 + macro-block 194 + comment/dead 6786 + coverage register raw 15533 = live 6950 + macro-block 18 + comment/dead 8565 coverage volatile raw 4448 = live 1890 + macro-block 82 + comment/dead 2476 coverage builtin raw 599 = live 445 + macro-block 0 + comment/dead 154 coverage attribute raw 76 = live 76 + macro-block 0 + comment/dead 0 class sites in-bodies file-scope bodies distinct TUs marked unmarked kinds - A pins 6910 6910 0 2334 869 1416 6910 0 {'pin': 6910} - B asm 14636 14623 13 5024 857 1599 5359 9277 {'launder': 1801, 'barrier': 1936, 'keepalive': 645, 'gte': 6858, 'gte-lever': 462, 'instruction': 236, 'asm-body': 13, 'gte-unsigned': 3, 'verbatim-body': 2682} - C volatile 1590 1438 152 496 95 610 14 1576 {'decl-body': 58, 'cast': 1378, 'decl-file': 152, 'param': 2} + A pins 6900 6900 0 2329 868 1416 6900 0 {'pin': 6900} + B asm 14631 14618 13 5019 856 1596 5354 9277 {'barrier': 1931, 'launder': 1801, 'keepalive': 645, 'gte': 6858, 'gte-lever': 462, 'gte-unsigned': 3, 'instruction': 236, 'asm-body': 13, 'verbatim-body': 2682} + C volatile 1590 1438 152 496 95 610 14 1576 {'decl-body': 58, 'decl-file': 152, 'cast': 1378, 'param': 2} D register 50 50 0 47 47 6 0 50 {'register': 50} E asm-label 7688 1265 6423 997 120 2084 0 7688 {'asm-label': 7688} F builtin 445 445 0 428 28 302 0 445 {'builtin': 445} G attribute 76 1 75 1 1 40 0 76 {'attribute': 76} - UNION A–D: 6,586 bodies · 1,450 distinct (addresses normalized) · 215 multi-copy classes holding 5,351 bodies · by kind {'ov': 6097, 'md': 133, 'shared': 181, 'main': 165, 'resident': 10} - THE PHASE'S NUMBER (pins + asm statements, GTE excluded): 12,003 sites in 3,060 bodies (1,160 distinct) · marked !FAKE 12,003 · UNMARKED 0 + UNION A–D: 6,576 bodies · 1,448 distinct (addresses normalized) · 213 multi-copy classes holding 5,341 bodies · by kind {'main': 165, 'ov': 6087, 'resident': 10, 'shared': 181, 'md': 133} + THE PHASE'S NUMBER (pins + asm statements, GTE excluded): 11,988 sites in 3,050 bodies (1,158 distinct) · marked !FAKE 11,988 · UNMARKED 0 orphan !FAKE markers (no pin/asm site on the line nor below): 0 GTE levers (clobbers beyond the canonical macro's): 462 sites (100 via a variant macro, 362 direct) · marked 462 · UNMARKED 0 · unsigned GTE statements 3 - per-TU asm macro definitions outside the GTE header: 314 {'gte': 150, 'instruction': 9, 'launder': 154, 'barrier': 1} (GTE variants 64) - pins: 6,910 · $0 106 · $sp 13 · with initializer 538 · volatile-qualified 3 · bare-name 15 · spellings {'__asm__': 6853, 'asm': 57} + per-TU asm macro definitions outside the GTE header: 314 {'gte': 150, 'launder': 154, 'instruction': 9, 'barrier': 1} (GTE variants 64) + pins: 6,900 · $0 106 · $sp 13 · with initializer 538 · volatile-qualified 3 · bare-name 15 · spellings {'__asm__': 6843, 'asm': 57} whole-body asm routines in C shells, manifest PERMANENT (hand asm, NOT levers): 22 routines · 2,682 sites (2,660 private copies + 22 shared headers); asm-bodies NOT permanent (levers): 13 site(s) ['func_8001E378:DECOMPILE-NOW', 'func_80020F34:DECOMPILE-NOW', 'func_800249F0:DECOMPILE-NOW', 'func_80025CBC:DECOMPILE-NOW', 'func_80026514:UNCERTAIN', 'func_800268D0:UNCERTAIN', 'func_80027058:DECOMPILE-NOW', 'func_80027200:DECOMPILE-NOW', 'func_800CBA44:DECOMPILE-NOW', 'func_8017D810:DECOMPILE-NOW', 'func_8017E26C:UNCERTAIN', 'func_80184440:DECOMPILE-NOW', 'func_801A3BCC:DECOMPILE-NOW'] - asm kinds: {'asm-body/direct': 13, 'barrier/direct': 1934, 'barrier/via-macro': 2, 'gte/direct': 200, 'gte/via-macro': 6658, 'gte-lever/direct': 362, 'gte-lever/via-macro': 100, 'gte-unsigned/direct': 3, 'instruction/direct': 214, 'instruction/via-macro': 22, 'keepalive/direct': 645, 'launder/direct': 1735, 'launder/via-macro': 66, 'verbatim-body/direct': 2682} - instruction mnemonics: {'la': 142, 'addu': 23, 'RTP_SND': 22, 'addiu': 22, '.section': 7, 'lui': 4, 'move': 4, 'lh': 3, 'and': 2, 'mult': 1, 'mfhi': 1, 'sll': 1, 'li': 1, 'lw': 1, 'nop': 1, 'srl': 1} - gte mnemonics: {'gte_ldv0': 757, 'gte_stlvnl': 593, 'gte_stsxy': 447, 'gte_rtps': 437, 'gte_stflg': 415, 'gte_rtpt': 352, 'gte_SetRotMatrix': 246, 'gte_stsxy3': 236, 'gte_rtv0tr': 228, 'gte_SetTransMatrix': 226, 'gte_ldv3c': 184, 'gte_ldv3': 177, 'gte_ldrgb': 164, 'gte_stsv': 161, 'lwc2': 159, 'gte_stsz4': 149, 'gte_stsz3': 147, 'gte_stszotz': 134, 'gte_ldIR0z': 134, 'gte_ldIRGB': 134, 'gte_dpcl': 134, 'gte_stORGB': 134, 'gte_stsxy3_f3': 111, 'gte_stclmv': 108, 'gte_nclip': 108, 'gte_stopz': 108, 'gte_stsxy3c': 108, 'gte_stsxy3_ft3': 79, 'gte_rtir': 75, 'gte_ldclmv': 72} - asm-bearing macro definitions: 314 (20 names, 3 with >1 text) kinds {'gte': 150, 'instruction': 9, 'launder': 154, 'barrier': 1} + asm kinds: {'asm-body/direct': 13, 'barrier/direct': 1929, 'barrier/via-macro': 2, 'gte/direct': 200, 'gte/via-macro': 6658, 'gte-lever/direct': 362, 'gte-lever/via-macro': 100, 'gte-unsigned/direct': 3, 'instruction/direct': 214, 'instruction/via-macro': 22, 'keepalive/direct': 645, 'launder/direct': 1735, 'launder/via-macro': 66, 'verbatim-body/direct': 2682} + instruction mnemonics: {'la': 142, 'addu': 23, 'addiu': 22, 'RTP_SND': 22, '.section': 7, 'lui': 4, 'move': 4, 'lh': 3, 'and': 2, 'mult': 1, 'mfhi': 1, 'sll': 1, 'li': 1, 'lw': 1, 'nop': 1, 'srl': 1} + gte mnemonics: {'gte_ldv0': 757, 'gte_stlvnl': 593, 'gte_stsxy': 447, 'gte_rtps': 437, 'gte_stflg': 415, 'gte_rtpt': 352, 'gte_SetRotMatrix': 246, 'gte_stsxy3': 236, 'gte_rtv0tr': 228, 'gte_SetTransMatrix': 226, 'gte_ldv3c': 184, 'gte_ldv3': 177, 'gte_ldrgb': 164, 'gte_stsv': 161, 'lwc2': 159, 'gte_stsz4': 149, 'gte_stsz3': 147, 'gte_stszotz': 134, 'gte_ldIR0z': 134, 'gte_ldIRGB': 134, 'gte_dpcl': 134, 'gte_stORGB': 134, 'gte_stsxy3_f3': 111, 'gte_nclip': 108, 'gte_stopz': 108, 'gte_stsxy3c': 108, 'gte_stclmv': 108, 'gte_stsxy3_ft3': 79, 'gte_rtir': 75, 'gte_ldclmv': 72} + asm-bearing macro definitions: 314 (20 names, 3 with >1 text) kinds {'gte': 150, 'launder': 154, 'instruction': 9, 'barrier': 1} controls (R39): src/800.c func_800226C0 pins got 14 expected 45 N-A src/shared/ov/func_80178004.h pins got 8 expected 26 N-A ov_SC03_006 func_80184034 bare-name pins got 0 expected 3 N-A engine_prelude.h asm sites (a macro definition only) got 0 expected 0 OK - elapsed 29.7 s + elapsed 31.0 s diff --git a/.run/P36/delever/calibration.json b/.run/P36/delever/calibration.json index 374c4a1c9..70c6a368f 100644 --- a/.run/P36/delever/calibration.json +++ b/.run/P36/delever/calibration.json @@ -1,7 +1,7 @@ { - "head": "321b540e7", + "head": "2a4f28f83", "stamp": "15956e4a96c4", - "generated": "2026-09-10 18:08", + "generated": "2026-09-10 18:13", "aliases": [ "main", "ov_SC03_014", @@ -21,206 +21,206 @@ "main": { "objects": 85, "identical": 85, - "seconds": 8.127000000000002, - "mean_s": 0.096 + "seconds": 7.8809999999999985, + "mean_s": 0.093 }, "ov_SC03_014": { "objects": 32, "identical": 32, - "seconds": 5.461000000000001, - "mean_s": 0.171 + "seconds": 5.423000000000001, + "mean_s": 0.169 }, "ov_SC03_015": { "objects": 32, "identical": 32, - "seconds": 5.338000000000001, - "mean_s": 0.167 + "seconds": 5.321999999999999, + "mean_s": 0.166 }, "ov_SC04_011": { "objects": 28, "identical": 28, - "seconds": 4.664000000000001, - "mean_s": 0.167 + "seconds": 4.66, + "mean_s": 0.166 } }, "per_object_seconds": { - "build/src/800.o": 0.863, - "build/src/800_b.o": 0.119, - "build/src/800_b_2.o": 0.357, - "build/src/800_b_o0a.o": 0.083, - "build/src/800_c.o": 0.227, - "build/src/800b2.o": 0.085, - "build/src/apicard1.o": 0.076, - "build/src/apicard2.o": 0.082, - "build/src/apicard3.o": 0.078, - "build/src/apicard4.o": 0.079, - "build/src/apicard5.o": 0.117, - "build/src/apicard6.o": 0.094, - "build/src/apicard7.o": 0.108, - "build/src/boot.o": 0.115, - "build/src/gap.o": 0.088, + "build/src/800.o": 0.854, + "build/src/800_b.o": 0.083, + "build/src/800_b_2.o": 0.338, + "build/src/800_b_o0a.o": 0.077, + "build/src/800_c.o": 0.215, + "build/src/800b2.o": 0.113, + "build/src/apicard1.o": 0.077, + "build/src/apicard2.o": 0.074, + "build/src/apicard3.o": 0.081, + "build/src/apicard4.o": 0.068, + "build/src/apicard5.o": 0.104, + "build/src/apicard6.o": 0.085, + "build/src/apicard7.o": 0.082, + "build/src/boot.o": 0.13, + "build/src/gap.o": 0.067, "build/src/libapi1.o": 0.085, - "build/src/libapi2.o": 0.069, - "build/src/libc2_1.o": 0.079, - "build/src/libc2_2.o": 0.074, - "build/src/libcd1.o": 0.082, - "build/src/libcd2.o": 0.069, - "build/src/libetc.o": 0.071, - "build/src/libgpu.o": 0.091, - "build/src/libgpu2.o": 0.088, - "build/src/libgs1.o": 0.078, - "build/src/libgs2.o": 0.073, - "build/src/libgs3.o": 0.069, - "build/src/libgs4.o": 0.079, - "build/src/libgs5.o": 0.079, - "build/src/libgs6.o": 0.097, - "build/src/libgs7.o": 0.074, - "build/src/libgs8.o": 0.085, - "build/src/libgte1.o": 0.079, - "build/src/libgte10.o": 0.078, - "build/src/libgte11.o": 0.078, - "build/src/libgte12.o": 0.076, - "build/src/libgte13.o": 0.078, - "build/src/libgte14.o": 0.073, - "build/src/libgte15.o": 0.076, - "build/src/libgte16.o": 0.078, - "build/src/libgte17.o": 0.079, - "build/src/libgte18.o": 0.083, - "build/src/libgte19.o": 0.078, - "build/src/libgte2.o": 0.077, - "build/src/libgte20.o": 0.075, - "build/src/libgte21.o": 0.074, - "build/src/libgte22.o": 0.076, - "build/src/libgte23.o": 0.071, - "build/src/libgte24.o": 0.081, - "build/src/libgte25.o": 0.078, - "build/src/libgte26.o": 0.083, - "build/src/libgte27.o": 0.075, - "build/src/libgte28.o": 0.079, - "build/src/libgte29.o": 0.078, - "build/src/libgte3.o": 0.077, - "build/src/libgte30.o": 0.081, - "build/src/libgte4.o": 0.078, - "build/src/libgte5.o": 0.074, - "build/src/libgte6.o": 0.089, - "build/src/libgte7.o": 0.086, - "build/src/libgte8.o": 0.079, - "build/src/libgte9.o": 0.084, - "build/src/libmcrd1.o": 0.091, - "build/src/libmcrd2.o": 0.087, - "build/src/libpad1.o": 0.078, - "build/src/libpad2.o": 0.092, - "build/src/sgap.o": 0.075, - "build/src/sgap_2.o": 0.076, - "build/src/sgap_3.o": 0.085, - "build/src/sgap_4.o": 0.086, - "build/src/sgap_5.o": 0.079, - "build/src/sgap_6.o": 0.077, - "build/src/sgap_8.o": 0.08, - "build/src/snd1.o": 0.085, + "build/src/libapi2.o": 0.074, + "build/src/libc2_1.o": 0.074, + "build/src/libc2_2.o": 0.07, + "build/src/libcd1.o": 0.083, + "build/src/libcd2.o": 0.074, + "build/src/libetc.o": 0.082, + "build/src/libgpu.o": 0.074, + "build/src/libgpu2.o": 0.084, + "build/src/libgs1.o": 0.073, + "build/src/libgs2.o": 0.076, + "build/src/libgs3.o": 0.064, + "build/src/libgs4.o": 0.066, + "build/src/libgs5.o": 0.073, + "build/src/libgs6.o": 0.092, + "build/src/libgs7.o": 0.078, + "build/src/libgs8.o": 0.069, + "build/src/libgte1.o": 0.08, + "build/src/libgte10.o": 0.076, + "build/src/libgte11.o": 0.081, + "build/src/libgte12.o": 0.079, + "build/src/libgte13.o": 0.079, + "build/src/libgte14.o": 0.078, + "build/src/libgte15.o": 0.074, + "build/src/libgte16.o": 0.074, + "build/src/libgte17.o": 0.082, + "build/src/libgte18.o": 0.076, + "build/src/libgte19.o": 0.07, + "build/src/libgte2.o": 0.071, + "build/src/libgte20.o": 0.077, + "build/src/libgte21.o": 0.072, + "build/src/libgte22.o": 0.075, + "build/src/libgte23.o": 0.075, + "build/src/libgte24.o": 0.077, + "build/src/libgte25.o": 0.082, + "build/src/libgte26.o": 0.073, + "build/src/libgte27.o": 0.079, + "build/src/libgte28.o": 0.077, + "build/src/libgte29.o": 0.079, + "build/src/libgte3.o": 0.084, + "build/src/libgte30.o": 0.09, + "build/src/libgte4.o": 0.073, + "build/src/libgte5.o": 0.082, + "build/src/libgte6.o": 0.073, + "build/src/libgte7.o": 0.078, + "build/src/libgte8.o": 0.073, + "build/src/libgte9.o": 0.082, + "build/src/libmcrd1.o": 0.089, + "build/src/libmcrd2.o": 0.076, + "build/src/libpad1.o": 0.084, + "build/src/libpad2.o": 0.09, + "build/src/sgap.o": 0.08, + "build/src/sgap_2.o": 0.07, + "build/src/sgap_3.o": 0.086, + "build/src/sgap_4.o": 0.082, + "build/src/sgap_5.o": 0.076, + "build/src/sgap_6.o": 0.075, + "build/src/sgap_8.o": 0.083, + "build/src/snd1.o": 0.081, "build/src/snd10.o": 0.076, - "build/src/snd11.o": 0.075, - "build/src/snd12.o": 0.072, - "build/src/snd2.o": 0.083, - "build/src/snd3.o": 0.079, + "build/src/snd11.o": 0.072, + "build/src/snd12.o": 0.082, + "build/src/snd2.o": 0.085, + "build/src/snd3.o": 0.073, "build/src/snd4.o": 0.076, - "build/src/snd5.o": 0.08, - "build/src/snd6.o": 0.087, - "build/src/snd7.o": 0.084, - "build/src/snd8.o": 0.074, - "build/src/snd9.o": 0.086, + "build/src/snd5.o": 0.074, + "build/src/snd6.o": 0.08, + "build/src/snd7.o": 0.077, + "build/src/snd8.o": 0.072, + "build/src/snd9.o": 0.082, "build/src/ov_SC03_014/ov_SC03_014.o": 0.154, - "build/src/ov_SC03_014/ov_SC03_014_after.o": 0.592, - "build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o": 0.454, - "build/src/ov_SC03_014/ov_SC03_014_jr_80135888.o": 0.076, - "build/src/ov_SC03_014/ov_SC03_014_jr_80135A4C.o": 0.076, - "build/src/ov_SC03_014/ov_SC03_014_jr_80135D20.o": 0.146, - "build/src/ov_SC03_014/ov_SC03_014_jr_801380E0.o": 0.189, - "build/src/ov_SC03_014/ov_SC03_014_jr_8013C98C.o": 0.139, - "build/src/ov_SC03_014/ov_SC03_014_jr_8013F350.o": 0.095, + "build/src/ov_SC03_014/ov_SC03_014_after.o": 0.594, + "build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o": 0.448, + "build/src/ov_SC03_014/ov_SC03_014_jr_80135888.o": 0.072, + "build/src/ov_SC03_014/ov_SC03_014_jr_80135A4C.o": 0.073, + "build/src/ov_SC03_014/ov_SC03_014_jr_80135D20.o": 0.156, + "build/src/ov_SC03_014/ov_SC03_014_jr_801380E0.o": 0.175, + "build/src/ov_SC03_014/ov_SC03_014_jr_8013C98C.o": 0.135, + "build/src/ov_SC03_014/ov_SC03_014_jr_8013F350.o": 0.092, "build/src/ov_SC03_014/ov_SC03_014_jr_8013FFD8.o": 0.086, - "build/src/ov_SC03_014/ov_SC03_014_jr_80140608.o": 0.225, - "build/src/ov_SC03_014/ov_SC03_014_jr_8015444C.o": 0.091, - "build/src/ov_SC03_014/ov_SC03_014_jr_80154C24.o": 0.203, - "build/src/ov_SC03_014/ov_SC03_014_jr_801588CC.o": 0.114, + "build/src/ov_SC03_014/ov_SC03_014_jr_80140608.o": 0.207, + "build/src/ov_SC03_014/ov_SC03_014_jr_8015444C.o": 0.088, + "build/src/ov_SC03_014/ov_SC03_014_jr_80154C24.o": 0.19, + "build/src/ov_SC03_014/ov_SC03_014_jr_801588CC.o": 0.123, "build/src/ov_SC03_014/ov_SC03_014_jr_80159C84.o": 0.08, - "build/src/ov_SC03_014/ov_SC03_014_jr_8015A3C8.o": 0.086, - "build/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.o": 0.113, - "build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o": 0.549, - "build/src/ov_SC03_014/ov_SC03_014_jr_8016AB6C.o": 0.308, - "build/src/ov_SC03_014/ov_SC03_014_jr_80171B4C.o": 0.116, - "build/src/ov_SC03_014/ov_SC03_014_jr_801734BC.o": 0.229, - "build/src/ov_SC03_014/ov_SC03_014_jr_801789AC.o": 0.07, - "build/src/ov_SC03_014/ov_SC03_014_jr_80178D40.o": 0.126, - "build/src/ov_SC03_014/ov_SC03_014_jr_8017A4AC.o": 0.083, - "build/src/ov_SC03_014/ov_SC03_014_jr_8017AE2C.o": 0.196, - "build/src/ov_SC03_014/ov_SC03_014_jr_8017EB7C.o": 0.221, - "build/src/ov_SC03_014/ov_SC03_014_jr_80184440.o": 0.057, - "build/src/ov_SC03_014/ov_SC03_014_jr_801848E4.o": 0.306, - "build/src/ov_SC03_014/ov_SC03_014_o0b.o": 0.065, - "build/src/ov_SC03_014/ov_SC03_014_o0c.o": 0.069, - "build/src/ov_SC03_014/ov_SC03_014_o0d.o": 0.065, - "build/src/ov_SC03_014/ov_SC03_014_o0e.o": 0.082, - "build/src/ov_SC03_015/ov_SC03_015.o": 0.153, - "build/src/ov_SC03_015/ov_SC03_015_after.o": 0.6, - "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o": 0.432, + "build/src/ov_SC03_014/ov_SC03_014_jr_8015A3C8.o": 0.082, + "build/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.o": 0.112, + "build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o": 0.546, + "build/src/ov_SC03_014/ov_SC03_014_jr_8016AB6C.o": 0.293, + "build/src/ov_SC03_014/ov_SC03_014_jr_80171B4C.o": 0.12, + "build/src/ov_SC03_014/ov_SC03_014_jr_801734BC.o": 0.24, + "build/src/ov_SC03_014/ov_SC03_014_jr_801789AC.o": 0.072, + "build/src/ov_SC03_014/ov_SC03_014_jr_80178D40.o": 0.119, + "build/src/ov_SC03_014/ov_SC03_014_jr_8017A4AC.o": 0.074, + "build/src/ov_SC03_014/ov_SC03_014_jr_8017AE2C.o": 0.193, + "build/src/ov_SC03_014/ov_SC03_014_jr_8017EB7C.o": 0.238, + "build/src/ov_SC03_014/ov_SC03_014_jr_80184440.o": 0.061, + "build/src/ov_SC03_014/ov_SC03_014_jr_801848E4.o": 0.32, + "build/src/ov_SC03_014/ov_SC03_014_o0b.o": 0.072, + "build/src/ov_SC03_014/ov_SC03_014_o0c.o": 0.07, + "build/src/ov_SC03_014/ov_SC03_014_o0d.o": 0.066, + "build/src/ov_SC03_014/ov_SC03_014_o0e.o": 0.072, + "build/src/ov_SC03_015/ov_SC03_015.o": 0.134, + "build/src/ov_SC03_015/ov_SC03_015_after.o": 0.575, + "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o": 0.441, "build/src/ov_SC03_015/ov_SC03_015_jr_80135888.o": 0.063, - "build/src/ov_SC03_015/ov_SC03_015_jr_80135A4C.o": 0.056, - "build/src/ov_SC03_015/ov_SC03_015_jr_80135D20.o": 0.135, - "build/src/ov_SC03_015/ov_SC03_015_jr_801380E0.o": 0.177, - "build/src/ov_SC03_015/ov_SC03_015_jr_8013C98C.o": 0.122, - "build/src/ov_SC03_015/ov_SC03_015_jr_8013F350.o": 0.089, - "build/src/ov_SC03_015/ov_SC03_015_jr_8013FFD8.o": 0.072, - "build/src/ov_SC03_015/ov_SC03_015_jr_80140608.o": 0.204, - "build/src/ov_SC03_015/ov_SC03_015_jr_8015444C.o": 0.087, + "build/src/ov_SC03_015/ov_SC03_015_jr_80135A4C.o": 0.061, + "build/src/ov_SC03_015/ov_SC03_015_jr_80135D20.o": 0.13, + "build/src/ov_SC03_015/ov_SC03_015_jr_801380E0.o": 0.182, + "build/src/ov_SC03_015/ov_SC03_015_jr_8013C98C.o": 0.137, + "build/src/ov_SC03_015/ov_SC03_015_jr_8013F350.o": 0.087, + "build/src/ov_SC03_015/ov_SC03_015_jr_8013FFD8.o": 0.087, + "build/src/ov_SC03_015/ov_SC03_015_jr_80140608.o": 0.206, + "build/src/ov_SC03_015/ov_SC03_015_jr_8015444C.o": 0.09, "build/src/ov_SC03_015/ov_SC03_015_jr_80154C24.o": 0.193, - "build/src/ov_SC03_015/ov_SC03_015_jr_801588CC.o": 0.102, - "build/src/ov_SC03_015/ov_SC03_015_jr_80159C84.o": 0.076, - "build/src/ov_SC03_015/ov_SC03_015_jr_8015A3C8.o": 0.077, + "build/src/ov_SC03_015/ov_SC03_015_jr_801588CC.o": 0.115, + "build/src/ov_SC03_015/ov_SC03_015_jr_80159C84.o": 0.082, + "build/src/ov_SC03_015/ov_SC03_015_jr_8015A3C8.o": 0.087, "build/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.o": 0.109, - "build/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.o": 0.528, - "build/src/ov_SC03_015/ov_SC03_015_jr_8016AB6C.o": 0.319, - "build/src/ov_SC03_015/ov_SC03_015_jr_80171B4C.o": 0.121, - "build/src/ov_SC03_015/ov_SC03_015_jr_801734BC.o": 0.23, - "build/src/ov_SC03_015/ov_SC03_015_jr_801789AC.o": 0.069, - "build/src/ov_SC03_015/ov_SC03_015_jr_80178D40.o": 0.123, - "build/src/ov_SC03_015/ov_SC03_015_jr_8017A4AC.o": 0.075, - "build/src/ov_SC03_015/ov_SC03_015_jr_8017AE2C.o": 0.197, - "build/src/ov_SC03_015/ov_SC03_015_jr_8017EB7C.o": 0.242, - "build/src/ov_SC03_015/ov_SC03_015_jr_80184440.o": 0.065, - "build/src/ov_SC03_015/ov_SC03_015_jr_801848E4.o": 0.322, - "build/src/ov_SC03_015/ov_SC03_015_o0b.o": 0.078, - "build/src/ov_SC03_015/ov_SC03_015_o0c.o": 0.067, - "build/src/ov_SC03_015/ov_SC03_015_o0d.o": 0.068, - "build/src/ov_SC03_015/ov_SC03_015_o0e.o": 0.087, - "build/src/ov_SC04_011/ov_SC04_011.o": 0.144, - "build/src/ov_SC04_011/ov_SC04_011_after.o": 0.487, - "build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o": 0.396, - "build/src/ov_SC04_011/ov_SC04_011_jr_80135888.o": 0.065, - "build/src/ov_SC04_011/ov_SC04_011_jr_80135A4C.o": 0.064, - "build/src/ov_SC04_011/ov_SC04_011_jr_80135D20.o": 0.132, - "build/src/ov_SC04_011/ov_SC04_011_jr_801380E0.o": 0.173, - "build/src/ov_SC04_011/ov_SC04_011_jr_8013C98C.o": 0.127, - "build/src/ov_SC04_011/ov_SC04_011_jr_8013F350.o": 0.086, - "build/src/ov_SC04_011/ov_SC04_011_jr_8013FFD8.o": 0.082, - "build/src/ov_SC04_011/ov_SC04_011_jr_80140608.o": 0.21, - "build/src/ov_SC04_011/ov_SC04_011_jr_8015444C.o": 0.088, - "build/src/ov_SC04_011/ov_SC04_011_jr_80154C24.o": 0.203, - "build/src/ov_SC04_011/ov_SC04_011_jr_801588CC.o": 0.111, - "build/src/ov_SC04_011/ov_SC04_011_jr_80159C84.o": 0.075, - "build/src/ov_SC04_011/ov_SC04_011_jr_8015A3C8.o": 0.077, - "build/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.o": 0.112, - "build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o": 0.418, - "build/src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.o": 0.261, - "build/src/ov_SC04_011/ov_SC04_011_jr_80171B4C.o": 0.122, + "build/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.o": 0.53, + "build/src/ov_SC03_015/ov_SC03_015_jr_8016AB6C.o": 0.31, + "build/src/ov_SC03_015/ov_SC03_015_jr_80171B4C.o": 0.117, + "build/src/ov_SC03_015/ov_SC03_015_jr_801734BC.o": 0.231, + "build/src/ov_SC03_015/ov_SC03_015_jr_801789AC.o": 0.07, + "build/src/ov_SC03_015/ov_SC03_015_jr_80178D40.o": 0.117, + "build/src/ov_SC03_015/ov_SC03_015_jr_8017A4AC.o": 0.079, + "build/src/ov_SC03_015/ov_SC03_015_jr_8017AE2C.o": 0.193, + "build/src/ov_SC03_015/ov_SC03_015_jr_8017EB7C.o": 0.226, + "build/src/ov_SC03_015/ov_SC03_015_jr_80184440.o": 0.058, + "build/src/ov_SC03_015/ov_SC03_015_jr_801848E4.o": 0.32, + "build/src/ov_SC03_015/ov_SC03_015_o0b.o": 0.071, + "build/src/ov_SC03_015/ov_SC03_015_o0c.o": 0.068, + "build/src/ov_SC03_015/ov_SC03_015_o0d.o": 0.065, + "build/src/ov_SC03_015/ov_SC03_015_o0e.o": 0.088, + "build/src/ov_SC04_011/ov_SC04_011.o": 0.143, + "build/src/ov_SC04_011/ov_SC04_011_after.o": 0.488, + "build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o": 0.398, + "build/src/ov_SC04_011/ov_SC04_011_jr_80135888.o": 0.064, + "build/src/ov_SC04_011/ov_SC04_011_jr_80135A4C.o": 0.065, + "build/src/ov_SC04_011/ov_SC04_011_jr_80135D20.o": 0.135, + "build/src/ov_SC04_011/ov_SC04_011_jr_801380E0.o": 0.168, + "build/src/ov_SC04_011/ov_SC04_011_jr_8013C98C.o": 0.129, + "build/src/ov_SC04_011/ov_SC04_011_jr_8013F350.o": 0.092, + "build/src/ov_SC04_011/ov_SC04_011_jr_8013FFD8.o": 0.076, + "build/src/ov_SC04_011/ov_SC04_011_jr_80140608.o": 0.209, + "build/src/ov_SC04_011/ov_SC04_011_jr_8015444C.o": 0.083, + "build/src/ov_SC04_011/ov_SC04_011_jr_80154C24.o": 0.195, + "build/src/ov_SC04_011/ov_SC04_011_jr_801588CC.o": 0.104, + "build/src/ov_SC04_011/ov_SC04_011_jr_80159C84.o": 0.074, + "build/src/ov_SC04_011/ov_SC04_011_jr_8015A3C8.o": 0.079, + "build/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.o": 0.106, + "build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o": 0.421, + "build/src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.o": 0.255, + "build/src/ov_SC04_011/ov_SC04_011_jr_80171B4C.o": 0.109, "build/src/ov_SC04_011/ov_SC04_011_jr_801734BC.o": 0.203, - "build/src/ov_SC04_011/ov_SC04_011_jr_801789AC.o": 0.07, - "build/src/ov_SC04_011/ov_SC04_011_jr_80178D40.o": 0.106, - "build/src/ov_SC04_011/ov_SC04_011_jr_8017A4AC.o": 0.08, - "build/src/ov_SC04_011/ov_SC04_011_jr_8017AE2C.o": 0.122, - "build/src/ov_SC04_011/ov_SC04_011_jr_8017D494.o": 0.525, - "build/src/ov_SC04_011/ov_SC04_011_o0b.o": 0.06, - "build/src/ov_SC04_011/ov_SC04_011_o0c.o": 0.065 + "build/src/ov_SC04_011/ov_SC04_011_jr_801789AC.o": 0.072, + "build/src/ov_SC04_011/ov_SC04_011_jr_80178D40.o": 0.118, + "build/src/ov_SC04_011/ov_SC04_011_jr_8017A4AC.o": 0.083, + "build/src/ov_SC04_011/ov_SC04_011_jr_8017AE2C.o": 0.126, + "build/src/ov_SC04_011/ov_SC04_011_jr_8017D494.o": 0.528, + "build/src/ov_SC04_011/ov_SC04_011_o0b.o": 0.067, + "build/src/ov_SC04_011/ov_SC04_011_o0c.o": 0.07 }, "ok": true, "seconds": 2.7 diff --git a/.run/P36/delever/ledger.jsonl b/.run/P36/delever/ledger.jsonl index f62fa80fd..32ee78487 100644 --- a/.run/P36/delever/ledger.jsonl +++ b/.run/P36/delever/ledger.jsonl @@ -27958,3 +27958,13 @@ {"ts": "2026-09-10 18:08:35", "label": "c40p", "rung": "E", "calib": {"head": "321b540e7", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_018/ov_SC05_018_jr_80185754.c", "fn": "func_80185C8C", "addr": 2149080204, "aliases": null, "header": false, "includers": 0, "nhash_before": "ab02047dfdd6f5e359fa63b1ece91fdec0971e1f", "nhash_after": "9b515b1117939aa896767ac9b4b1c5ac07a2f77a", "source": "propagate:src/ov_SC03_002/ov_SC03_002_jr_8018431C.c:func_80184854", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.075, "objects": ["build/src/ov_SC05_018/ov_SC05_018_jr_80185754.o"], "before_text": "s32 func_80185C8C(void *a0) {\n\n extern u8 D_801202A0[];\n u8 *p;\n u8 *end;\n s32 t;\n u16 tag;\n s16 out[3];\n s16 in[3];\n\n p = D_801202A0;\n end = p + 0x6480;\n if (p != end) {\n do {\n tag = *(u16 *)p;\n if (tag != 0 && tag != 0x61 && func_80185D98((s32)p) != 0) {\n t = *(s32 *)(p + 0x20);\n if (t != 0 && *(s32 *)(t + 0x24) != 0 && *(s32 *)(t + 0x4) >= 0) {\n in[0] = *(u16 *)(p + 0x6);\n in[1] = *(u16 *)(p + 0xA);\n in[2] = *(u16 *)(p + 0xE);\n func_8012F2E8((s32)a0, (s32)in, (s32)out);\n if (func_8012CB64((s32)out, -0xA0, 0x80, -0xC0, 0x80) != 0) {\n __asm__(\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus9)\n return 1;\n }\n }\n }\n p += 0x10C;\n } while (p != end);\n }\n return 0;\n}\n", "after_text": "s32 func_80185C8C(void *a0) {\n\n extern u8 D_801202A0[];\n u8 *p;\n u8 *end;\n s32 t;\n u16 tag;\n s16 out[3];\n s16 in[3];\n\n p = D_801202A0;\n end = p + 0x6480;\n for (; p != end; p += 0x10C) {\n tag = *(u16 *)p;\n if (tag != 0 && tag != 0x61 && func_80185D98((s32)p) != 0) {\n t = *(s32 *)(p + 0x20);\n if (t != 0 && *(s32 *)(t + 0x24) != 0 && *(s32 *)(t + 0x4) >= 0) {\n in[0] = *(u16 *)(p + 0x6);\n in[1] = *(u16 *)(p + 0xA);\n in[2] = *(u16 *)(p + 0xE);\n func_8012F2E8((s32)a0, (s32)in, (s32)out);\n if (func_8012CB64((s32)out, -0xA0, 0x80, -0xC0, 0x80) != 0) {\n return 1;\n }\n }\n }\n }\n return 0;\n}\n"} {"ts": "2026-09-10 18:08:35", "label": "c40p", "rung": "E", "calib": {"head": "321b540e7", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_015/ov_SC04_015_jr_801820DC.c", "fn": "func_80182614", "addr": 2149066260, "aliases": null, "header": false, "includers": 0, "nhash_before": "ab02047dfdd6f5e359fa63b1ece91fdec0971e1f", "nhash_after": "9b515b1117939aa896767ac9b4b1c5ac07a2f77a", "source": "propagate:src/ov_SC03_002/ov_SC03_002_jr_8018431C.c:func_80184854", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.097, "objects": ["build/src/ov_SC04_015/ov_SC04_015_jr_801820DC.o"], "before_text": "s32 func_80182614(void *a0) {\n\n extern u8 D_801202A0[];\n u8 *p;\n u8 *end;\n s32 t;\n u16 tag;\n s16 out[3];\n s16 in[3];\n\n p = D_801202A0;\n end = p + 0x6480;\n if (p != end) {\n do {\n tag = *(u16 *)p;\n if (tag != 0 && tag != 0x61 && func_80182720((s32)p) != 0) {\n t = *(s32 *)(p + 0x20);\n if (t != 0 && *(s32 *)(t + 0x24) != 0 && *(s32 *)(t + 0x4) >= 0) {\n in[0] = *(u16 *)(p + 0x6);\n in[1] = *(u16 *)(p + 0xA);\n in[2] = *(u16 *)(p + 0xE);\n func_8012F2E8((s32)a0, (s32)in, (s32)out);\n if (func_8012CB64((s32)out, -0xA0, 0x80, -0xC0, 0x80) != 0) {\n __asm__(\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus9)\n return 1;\n }\n }\n }\n p += 0x10C;\n } while (p != end);\n }\n return 0;\n}\n", "after_text": "s32 func_80182614(void *a0) {\n\n extern u8 D_801202A0[];\n u8 *p;\n u8 *end;\n s32 t;\n u16 tag;\n s16 out[3];\n s16 in[3];\n\n p = D_801202A0;\n end = p + 0x6480;\n for (; p != end; p += 0x10C) {\n tag = *(u16 *)p;\n if (tag != 0 && tag != 0x61 && func_80182720((s32)p) != 0) {\n t = *(s32 *)(p + 0x20);\n if (t != 0 && *(s32 *)(t + 0x24) != 0 && *(s32 *)(t + 0x4) >= 0) {\n in[0] = *(u16 *)(p + 0x6);\n in[1] = *(u16 *)(p + 0xA);\n in[2] = *(u16 *)(p + 0xE);\n func_8012F2E8((s32)a0, (s32)in, (s32)out);\n if (func_8012CB64((s32)out, -0xA0, 0x80, -0xC0, 0x80) != 0) {\n return 1;\n }\n }\n }\n }\n return 0;\n}\n"} {"ts": "2026-09-10 18:08:35", "label": "c40p", "rung": "E", "calib": {"head": "321b540e7", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_020/ov_SC04_020_jr_8018254C.c", "fn": "func_80182A84", "addr": 2149067396, "aliases": null, "header": false, "includers": 0, "nhash_before": "ab02047dfdd6f5e359fa63b1ece91fdec0971e1f", "nhash_after": "9b515b1117939aa896767ac9b4b1c5ac07a2f77a", "source": "propagate:src/ov_SC03_002/ov_SC03_002_jr_8018431C.c:func_80184854", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.066, "objects": ["build/src/ov_SC04_020/ov_SC04_020_jr_8018254C.o"], "before_text": "s32 func_80182A84(void *a0) {\n\n extern u8 D_801202A0[];\n u8 *p;\n u8 *end;\n s32 t;\n u16 tag;\n s16 out[3];\n s16 in[3];\n\n p = D_801202A0;\n end = p + 0x6480;\n if (p != end) {\n do {\n tag = *(u16 *)p;\n if (tag != 0 && tag != 0x61 && func_80182B90((s32)p) != 0) {\n t = *(s32 *)(p + 0x20);\n if (t != 0 && *(s32 *)(t + 0x24) != 0 && *(s32 *)(t + 0x4) >= 0) {\n in[0] = *(u16 *)(p + 0x6);\n in[1] = *(u16 *)(p + 0xA);\n in[2] = *(u16 *)(p + 0xE);\n func_8012F2E8((s32)a0, (s32)in, (s32)out);\n if (func_8012CB64((s32)out, -0xA0, 0x80, -0xC0, 0x80) != 0) {\n __asm__(\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus9)\n return 1;\n }\n }\n }\n p += 0x10C;\n } while (p != end);\n }\n return 0;\n}\n", "after_text": "s32 func_80182A84(void *a0) {\n\n extern u8 D_801202A0[];\n u8 *p;\n u8 *end;\n s32 t;\n u16 tag;\n s16 out[3];\n s16 in[3];\n\n p = D_801202A0;\n end = p + 0x6480;\n for (; p != end; p += 0x10C) {\n tag = *(u16 *)p;\n if (tag != 0 && tag != 0x61 && func_80182B90((s32)p) != 0) {\n t = *(s32 *)(p + 0x20);\n if (t != 0 && *(s32 *)(t + 0x24) != 0 && *(s32 *)(t + 0x4) >= 0) {\n in[0] = *(u16 *)(p + 0x6);\n in[1] = *(u16 *)(p + 0xA);\n in[2] = *(u16 *)(p + 0xE);\n func_8012F2E8((s32)a0, (s32)in, (s32)out);\n if (func_8012CB64((s32)out, -0xA0, 0x80, -0xC0, 0x80) != 0) {\n return 1;\n }\n }\n }\n }\n return 0;\n}\n"} +{"ts": "2026-09-10 18:13:47", "label": "c42", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_091/ov_SC03_091_jr_8018326C.c", "fn": "func_80186A8C", "addr": 2149083788, "aliases": null, "header": false, "includers": 0, "nhash_before": "b4fb741e9978fd26c0b267d9729153c5c5f04592", "nhash_after": "a3ae9d0fe197f788c28bb910f69ce3c50ffb0819", "source": "T7 agent c42", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.194, "objects": ["build/src/ov_SC03_091/ov_SC03_091_jr_8018326C.o"], "before_text": "void func_80186A8C(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_801A8C0C[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_801877EC(a0);\n func_8018771C(a0, D_801A8C0C[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n", "after_text": "void func_80186A8C(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_801A8C0C[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_801877EC(a0);\n func_8018771C(a0, D_801A8C0C[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n"} +{"ts": "2026-09-10 18:13:50", "label": "c42p", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c", "fn": "func_80185BE4", "addr": 2149080036, "aliases": null, "header": false, "includers": 0, "nhash_before": "b4fb741e9978fd26c0b267d9729153c5c5f04592", "nhash_after": "a3ae9d0fe197f788c28bb910f69ce3c50ffb0819", "source": "propagate:src/ov_SC03_091/ov_SC03_091_jr_8018326C.c:func_80186A8C", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.346, "objects": ["build/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.o"], "before_text": "void func_80185BE4(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_801A5BE0[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_80186944(a0);\n func_80186874(a0, D_801A5BE0[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n", "after_text": "void func_80185BE4(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_801A5BE0[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_80186944(a0);\n func_80186874(a0, D_801A5BE0[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n"} +{"ts": "2026-09-10 18:13:50", "label": "c42p", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c", "fn": "func_8017F4DC", "addr": 2149053660, "aliases": null, "header": false, "includers": 0, "nhash_before": "b4fb741e9978fd26c0b267d9729153c5c5f04592", "nhash_after": "a3ae9d0fe197f788c28bb910f69ce3c50ffb0819", "source": "propagate:src/ov_SC03_091/ov_SC03_091_jr_8018326C.c:func_80186A8C", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.o"], "before_text": "void func_8017F4DC(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_80198DFC[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_8018023C(a0);\n func_8018016C(a0, D_80198DFC[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n", "after_text": "void func_8017F4DC(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_80198DFC[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_8018023C(a0);\n func_8018016C(a0, D_80198DFC[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n"} +{"ts": "2026-09-10 18:13:51", "label": "c42p", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_098/ov_SC03_098_jr_8017D898.c", "fn": "func_8018106C", "addr": 2149060716, "aliases": null, "header": false, "includers": 0, "nhash_before": "b4fb741e9978fd26c0b267d9729153c5c5f04592", "nhash_after": "a3ae9d0fe197f788c28bb910f69ce3c50ffb0819", "source": "propagate:src/ov_SC03_091/ov_SC03_091_jr_8018326C.c:func_80186A8C", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.222, "objects": ["build/src/ov_SC03_098/ov_SC03_098_jr_8017D898.o"], "before_text": "void func_8018106C(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_8019E1F0[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_80181DCC(a0);\n func_80181CFC(a0, D_8019E1F0[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n", "after_text": "void func_8018106C(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_8019E1F0[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_80181DCC(a0);\n func_80181CFC(a0, D_8019E1F0[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n"} +{"ts": "2026-09-10 18:13:51", "label": "c42p", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_094/ov_SC03_094_jr_8017BEBC.c", "fn": "func_80180864", "addr": 2149058660, "aliases": null, "header": false, "includers": 0, "nhash_before": "b4fb741e9978fd26c0b267d9729153c5c5f04592", "nhash_after": "a3ae9d0fe197f788c28bb910f69ce3c50ffb0819", "source": "propagate:src/ov_SC03_091/ov_SC03_091_jr_8018326C.c:func_80186A8C", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.263, "objects": ["build/src/ov_SC03_094/ov_SC03_094_jr_8017BEBC.o"], "before_text": "void func_80180864(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_801A8D84[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4);\n } else {\n t = ang << 4;\n }\n {\n register s32 av __asm__(\"$5\"); // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n av = t - 0x4000;\n func_8012B178(a0, av);\n }\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_801815C4(a0);\n func_801814F4(a0, D_801A8D84[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n", "after_text": "void func_80180864(s32 a0) {\n\n extern u8 D_800AF630[];\n extern s32 D_801A8D84[];\n s32 pad[4]; /* idiom 6: 16 bytes of dead locals at sp+0x10 => frame 0x30 */\n u8 *m = D_800AF630;\n s32 ang;\n s32 off;\n s32 base;\n\n ang = func_8004787C(*(s32 *)(a0 + 0xE4));\n if (*(s16 *)(a0 + 0xAA) == 0) {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 2) + 0x1000;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - (ang >> 1);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 1) + 0x1000;\n } else {\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = (ang >> 3) + 0x700;\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x700 - (ang >> 2);\n *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = (ang >> 2) + 0x700;\n }\n\n if (*(u16 *)(m + 0xA3AA) % *(s16 *)(a0 + 0xFE) == 0) {\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + func_8012B8E4(a0, 0x20);\n }\n\n switch (*(u16 *)(a0 + 0x34)) {\n case 0: {\n s32 t;\n s32 r;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n r = ((s32 (*)(s32))func_8012CBA4)(a0);\n if (r & 0x8000) {\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if ((r & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (--*(s32 *)(a0 + 0xE8) == 0) {\n if (rand() & 1) {\n s32 v;\n *(u16 *)(a0 + 0x34) = 1;\n *(s32 *)(a0 + 0x1C) = 0x20;\n off = rand() % 1024;\n base = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12);\n if ((rand() & 1) == 0) {\n v = base - off;\n } else {\n v = base + off;\n }\n *(s32 *)(a0 + 0xE0) = v;\n } else {\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n }\n break;\n }\n case 1: {\n s32 t;\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (ang >= 0) {\n t = -(ang << 4) - 0x4000;\n } else {\n t = (ang << 4) - 0x4000;\n }\n func_8012B178(a0, t);\n if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) {\n func_8012ADE4((u8 *)a0);\n *(u16 *)(a0 + 0x34) = 2;\n *(s32 *)(a0 + 0xE0) = *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x800;\n *(s32 *)(a0 + 0x1C) = rand() % 10 + 0x14;\n } else if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n *(s32 *)(a0 + 0xE8) = 0x40;\n }\n break;\n }\n case 2: {\n s32 d = func_8012B608(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12),\n *(s32 *)(a0 + 0xE0), 0x14);\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d;\n if (func_8012BEE8(a0) != 0) {\n *(u16 *)(a0 + 0x34) = 0;\n func_8012B030((u8 *)a0);\n }\n break;\n }\n }\n\n func_801815C4(a0);\n func_801814F4(a0, D_801A8D84[*(u16 *)(a0 + 0x70) & 0xF]);\n *(s32 *)(a0 + 0xE4) = (*(s32 *)(a0 + 0xE4) + 0x40) & 0x7FF;\n if (*(s32 *)(a0 + 0x14) > 0x100000) {\n *(s32 *)(a0 + 0x14) = 0x100000;\n }\n}\n"} +{"ts": "2026-09-10 18:13:54", "label": "c42", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c", "fn": "func_80182058", "addr": 2149064792, "aliases": null, "header": false, "includers": 0, "nhash_before": "5a69d74b3f3a5a1804675f9862a18aadeb90d107", "nhash_after": "99d3acfa024d30b3aa26333d51e8f1278e4a4eb1", "source": "T7 agent c42", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.285, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.o"], "before_text": "s32 func_80182058(void *a0)\n{\n\n extern s16 D_801EEAF0;\n extern s16 D_801EEAF2;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n /* LOAD-BEARING zero-byte cross-jump barrier (cookbook \u00a75a).\n * Without it gcc's find_cross_jump merges this `move v0,0; j epi`\n * tail with the identical case-2 failure tail -> 58 ins instead of\n * 60, and the case-2 `beq` then loses its delay-slot fill. */\n __asm__ __volatile__(\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus7)\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) != 1) {\n return 0;\n }\n goto hit;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n return 0;\n }\n hit:\n D_801EEAF0 = st;\n D_801EEAF2 = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n", "after_text": "s32 func_80182058(void *a0)\n{\n\n extern s16 D_801EEAF0;\n extern s16 D_801EEAF2;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) == 1) {\n goto hit;\n }\n goto fail;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n goto fail;\n }\n hit:\n D_801EEAF0 = st;\n D_801EEAF2 = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n fail: /* the case-2/case-4 failures share this one `return 0`: a return\n * falling out of a conditional (as the first one does) is what\n * jump2's cross-jump would merge the early return into */\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n"} +{"ts": "2026-09-10 18:13:56", "label": "c42p", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c", "fn": "func_801834C0", "addr": 2149070016, "aliases": null, "header": false, "includers": 0, "nhash_before": "5a69d74b3f3a5a1804675f9862a18aadeb90d107", "nhash_after": "99d3acfa024d30b3aa26333d51e8f1278e4a4eb1", "source": "propagate:src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c:func_80182058", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.262, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.o"], "before_text": "s32 func_801834C0(void *a0)\n{\n\n extern s16 D_801EEB00;\n extern s16 D_801EEB02;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n /* LOAD-BEARING zero-byte cross-jump barrier (cookbook \u00a75a).\n * Without it gcc's find_cross_jump merges this `move v0,0; j epi`\n * tail with the identical case-2 failure tail -> 58 ins instead of\n * 60, and the case-2 `beq` then loses its delay-slot fill. */\n __asm__ __volatile__(\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus7)\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) != 1) {\n return 0;\n }\n goto hit;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n return 0;\n }\n hit:\n D_801EEB00 = st;\n D_801EEB02 = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n", "after_text": "s32 func_801834C0(void *a0)\n{\n\n extern s16 D_801EEB00;\n extern s16 D_801EEB02;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) == 1) {\n goto hit;\n }\n goto fail;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n goto fail;\n }\n hit:\n D_801EEB00 = st;\n D_801EEB02 = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n fail: /* the case-2/case-4 failures share this one `return 0`: a return\n * falling out of a conditional (as the first one does) is what\n * jump2's cross-jump would merge the early return into */\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n"} +{"ts": "2026-09-10 18:13:57", "label": "c42p", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c", "fn": "func_8017FB10", "addr": 2149055248, "aliases": null, "header": false, "includers": 0, "nhash_before": "5a69d74b3f3a5a1804675f9862a18aadeb90d107", "nhash_after": "99d3acfa024d30b3aa26333d51e8f1278e4a4eb1", "source": "propagate:src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c:func_80182058", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.166, "objects": ["build/src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.o"], "before_text": "s32 func_8017FB10(void *a0)\n{\n\n extern s16 D_801ECE68;\n extern s16 D_801ECE6A;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n /* LOAD-BEARING zero-byte cross-jump barrier (cookbook \u00a75a).\n * Without it gcc's find_cross_jump merges this `move v0,0; j epi`\n * tail with the identical case-2 failure tail -> 58 ins instead of\n * 60, and the case-2 `beq` then loses its delay-slot fill. */\n __asm__ __volatile__(\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus7)\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) != 1) {\n return 0;\n }\n goto hit;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n return 0;\n }\n hit:\n D_801ECE68 = st;\n D_801ECE6A = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n", "after_text": "s32 func_8017FB10(void *a0)\n{\n\n extern s16 D_801ECE68;\n extern s16 D_801ECE6A;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) == 1) {\n goto hit;\n }\n goto fail;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n goto fail;\n }\n hit:\n D_801ECE68 = st;\n D_801ECE6A = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n fail: /* the case-2/case-4 failures share this one `return 0`: a return\n * falling out of a conditional (as the first one does) is what\n * jump2's cross-jump would merge the early return into */\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n"} +{"ts": "2026-09-10 18:13:57", "label": "c42p", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c", "fn": "func_801825BC", "addr": 2149066172, "aliases": null, "header": false, "includers": 0, "nhash_before": "5a69d74b3f3a5a1804675f9862a18aadeb90d107", "nhash_after": "99d3acfa024d30b3aa26333d51e8f1278e4a4eb1", "source": "propagate:src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c:func_80182058", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.481, "objects": ["build/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.o", "build/src/ov_SC04_019/ov_SC04_019_jr_8017AE2C.o"], "before_text": "s32 func_801825BC(void *a0)\n{\n\n extern s16 D_801E7020;\n extern s16 D_801E7022;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n /* LOAD-BEARING zero-byte cross-jump barrier (cookbook \u00a75a).\n * Without it gcc's find_cross_jump merges this `move v0,0; j epi`\n * tail with the identical case-2 failure tail -> 58 ins instead of\n * 60, and the case-2 `beq` then loses its delay-slot fill. */\n __asm__ __volatile__(\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus7)\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) != 1) {\n return 0;\n }\n goto hit;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n return 0;\n }\n hit:\n D_801E7020 = st;\n D_801E7022 = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n", "after_text": "s32 func_801825BC(void *a0)\n{\n\n extern s16 D_801E7020;\n extern s16 D_801E7022;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) == 1) {\n goto hit;\n }\n goto fail;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n goto fail;\n }\n hit:\n D_801E7020 = st;\n D_801E7022 = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n fail: /* the case-2/case-4 failures share this one `return 0`: a return\n * falling out of a conditional (as the first one does) is what\n * jump2's cross-jump would merge the early return into */\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n"} +{"ts": "2026-09-10 18:13:58", "label": "c42p", "rung": "E", "calib": {"head": "2a4f28f83", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_017/ov_SC05_017_jr_801808D4.c", "fn": "func_80180FB4", "addr": 2149060532, "aliases": null, "header": false, "includers": 0, "nhash_before": "5a69d74b3f3a5a1804675f9862a18aadeb90d107", "nhash_after": "99d3acfa024d30b3aa26333d51e8f1278e4a4eb1", "source": "propagate:src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c:func_80182058", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.087, "objects": ["build/src/ov_SC05_017/ov_SC05_017_jr_801808D4.o"], "before_text": "s32 func_80180FB4(void *a0)\n{\n\n extern s16 D_801ECE78;\n extern s16 D_801ECE7A;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n /* LOAD-BEARING zero-byte cross-jump barrier (cookbook \u00a75a).\n * Without it gcc's find_cross_jump merges this `move v0,0; j epi`\n * tail with the identical case-2 failure tail -> 58 ins instead of\n * 60, and the case-2 `beq` then loses its delay-slot fill. */\n __asm__ __volatile__(\"\"); // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus9)\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) != 1) {\n return 0;\n }\n goto hit;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n return 0;\n }\n hit:\n D_801ECE78 = st;\n D_801ECE7A = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n", "after_text": "s32 func_80180FB4(void *a0)\n{\n\n extern s16 D_801ECE78;\n extern s16 D_801ECE7A;\n void *p;\n u16 st;\n\n if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) {\n return 0;\n }\n\n p = *(void **)((s32)a0 + 0x64);\n st = *(u16 *)((s32)p + 0x2);\n switch (st) {\n case 3:\n *(s16 *)((s32)p + 0x2) = 8;\n break;\n case 2:\n if (*(u16 *)((s32)p + 0x34) == 1) {\n goto hit;\n }\n goto fail;\n case 4:\n if (*(u16 *)((s32)p + 0x34) != 0) {\n goto fail;\n }\n hit:\n D_801ECE78 = st;\n D_801ECE7A = *(u16 *)((s32)p + 0x34);\n *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10;\n break;\n default:\n fail: /* the case-2/case-4 failures share this one `return 0`: a return\n * falling out of a conditional (as the first one does) is what\n * jump2's cross-jump would merge the early return into */\n return 0;\n }\n\n func_80178BF8();\n return (s32)func_80172710;\n}\n"} diff --git a/decomp-architect/corpus/tools/P10/delever_pack.py b/decomp-architect/corpus/tools/P10/delever_pack.py index f141ddae0..52e6bee8a 100644 --- a/decomp-architect/corpus/tools/P10/delever_pack.py +++ b/decomp-architect/corpus/tools/P10/delever_pack.py @@ -100,12 +100,17 @@ def related_bodies(tu, fn, target_text, alias, top=6, max_lines=600): for r in recs: if r.get("form") == "def" and r.get("name") == fn: body = txt[ls[r["line"] - 1]:ls[r["end"]]] if r["end"] < len(ls) else txt[ls[r["line"] - 1]:] - if "!FAKE" not in body and "__asm__ __volatile__" not in body: + # SAME NAME IS NOT SAME FUNCTION: overlays reuse addresses (S103, agent c43 — the func_80185578 listed + # here from ov_SC03_014 was a one-line different function). Evidence required: a shared callee/global + # and a comparable size. + n_t, n_b = target_text.count("\n") or 1, body.count("\n") or 1 + shares = (set(SYM.findall(body)) - {fn}) & want + if "!FAKE" not in body and "__asm__ __volatile__" not in body and shares and 0.6 <= n_b / n_t <= 1.6: same.append((rel, r["line"], body)) break head = [] for rel, line, body in same: - head += [f"=== {fn} ALREADY LEVER-FREE in {rel}:{line} — a variant of your function: port it (R71) ===", body.rstrip(), ""] + head += [f"=== {fn} ALREADY LEVER-FREE in {rel}:{line} — same name, shares symbols and size: PROBABLY a variant; diff it before porting (R71) ===", body.rstrip(), ""] seen, out = set(), head + [f"=== lever-free bodies in {alias} sharing a callee or global with {fn} " f"({len(cands)} found; top {top} by shared symbols) — read them for the SHAPE ==="] for _, n, name, rel, line, shared, body in cands: diff --git a/docs/lever-progress.tsv b/docs/lever-progress.tsv index d04e09080..4f5ceea52 100644 --- a/docs/lever-progress.tsv +++ b/docs/lever-progress.tsv @@ -47,3 +47,4 @@ date milestone head sites_AB pins asm bodies_AB distinct_AB marked unmarked gte_ 2026-09-10 S103: c36 + c35 (four ov_SC07_006/ov_SC06_010 classes, 39 bodies); R19 reads cast arity dd5e44c24 12481 7186 5295 3260 1207 12481 0 462 314 1590 50 7680 445 76 2026-09-10 S103: extern-variant re-propagation (97), R19 cast regen (8 classes), c39 + c41 + c34 + c32 closes 7d5964b27 12033 6926 5107 3090 1164 12033 0 462 314 1590 50 7688 445 76 2026-09-10 S103: c38 + c40 (four tier classes, 30 bodies) 321b540e7 12003 6910 5093 3060 1160 12003 0 462 314 1590 50 7688 445 76 +2026-09-10 S103: c42 func_80186A8C + func_80182058 (10 bodies) 2a4f28f83 11988 6900 5088 3050 1158 11988 0 462 314 1590 50 7688 445 76 diff --git a/docs/levers.md b/docs/levers.md index c22110a33..3b7c06b24 100644 --- a/docs/levers.md +++ b/docs/levers.md @@ -93,6 +93,7 @@ counted, not marked). E, F and G belong to the canonical type layer and are the | 2026-09-10 | S103: c36 + c35 (four ov_SC07_006/ov_SC06_010 classes, 39 bodies); R19 reads cast arity | 7186 | 5295 | **12481** | 3260 | 1207 | 462 | 314 | 1590 | 50 | 7680 | 445 | 76 | `dd5e44c24` | | 2026-09-10 | S103: extern-variant re-propagation (97), R19 cast regen (8 classes), c39 + c41 + c34 + c32 closes | 6926 | 5107 | **12033** | 3090 | 1164 | 462 | 314 | 1590 | 50 | 7688 | 445 | 76 | `7d5964b27` | | 2026-09-10 | S103: c38 + c40 (four tier classes, 30 bodies) | 6910 | 5093 | **12003** | 3060 | 1160 | 462 | 314 | 1590 | 50 | 7688 | 445 | 76 | `321b540e7` | +| 2026-09-10 | S103: c42 func_80186A8C + func_80182058 (10 bodies) | 6900 | 5088 | **11988** | 3050 | 1158 | 462 | 314 | 1590 | 50 | 7688 | 445 | 76 | `2a4f28f83` | ### The campaign — every batch, from the ledger (derived on every render) @@ -264,7 +265,9 @@ counted, not marked). E, F and G belong to the canonical type layer and are the | `c38p` | 2026-09-10 | E | 0 | 0 | 0 | 14 | 14 | | `c40` | 2026-09-10 | E | 0 | 0 | 0 | 2 | 2 | | `c40p` | 2026-09-10 | E | 0 | 0 | 0 | 12 | 12 | -| **total** | | | **17,119** | **20,778** | **283** | **22,417** | **9,676** | +| `c42` | 2026-09-10 | E | 0 | 0 | 0 | 3 | 2 | +| `c42p` | 2026-09-10 | E | 0 | 0 | 0 | 12 | 8 | +| **total** | | | **17,119** | **20,778** | **283** | **22,432** | **9,686** | *Generated by `tools/lever_progress.py --render` from `.run/P36/census/lever_census.json` and `.run/P36/delever/ledger.jsonl`; the series lives in `docs/lever-progress.tsv` (R75: published numbers are generated, never typed).* diff --git a/phase-ends/CURRENT_PHASE.md b/phase-ends/CURRENT_PHASE.md index 12e5be023..b697caa4f 100644 --- a/phase-ends/CURRENT_PHASE.md +++ b/phase-ends/CURRENT_PHASE.md @@ -1694,6 +1694,16 @@ accumulate here as the phase produces them.** merge; and a hand-rotated `if … do … while` written as a real `for` loop, whose `NOTE_INSN_LOOP_VTOP` (`jump.c:2306`) makes reorg's `mostly_true_jump` predict taken (`reorg.c:1364-1372`) and fill the slot from the target. Tools: `cc1_dumps_tu.sh` gains `-dd` (`.dbr`); METHOD notes `--keep`'s path is the LAST output line. +- **S103 — c42: `func_80186A8C` (ov_SC03_091, 8 → 0; 4/4) and `func_80182058` (ov_SC03_001, 10 → 0; 4/4) CLOSED — + both through jump2's cross-jump in ways METHOD did not yet list.** func_80186A8C: the `- 0x4000` folded into both arms + of the sign pick and `t` passed bare — `t` set in two blocks takes `$5` by copy preference, and cross-jump merges the two + identical arm tails into the target's single join instruction (argument registers load in order on MIPS, + `calls.c:1860-1881`); func_80182058: the case failures sent to one labelled `return 0` — cross-jump lowers its match + threshold for a block at a label (`jump.c:2406-2410`) or right after a conditional jump past it (`:2516-2519`), so which + block SURVIVES the merge is decided by where the labels are; the tree's "load-bearing zero-byte cross-jump barrier" + comment was refuted. METHOD note: for a cross-jump residual, find which label survives in `.jump2`, yours and the tree's. +- **S103 — the first MINIMUM-LEVER draw: c46 on `func_80177B5C`** (c19's plain body at 2; goal: 0 with the fewest marked + levers, ideally one, instead of 23 per copy × 132). - **S103 — WHERE THE RESIDUE IS (measured at 12,003 sites): ~70% of the remaining lever weight sits in 9 classes of ≥100 copies, every one already read by an agent with a written reading** (approx. copies × sites/body: func_8013D9B0 125×34 — c17 15 plain, the GTE-macro question; func_80177B5C 132×23 — c19 2, one `or` late; diff --git a/src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c b/src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c index 7091fb8de..c1ee3b2da 100644 --- a/src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c +++ b/src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c @@ -4283,15 +4283,11 @@ void func_8017F4DC(s32 a0) { s32 t; s32 r; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); r = ((s32 (*)(s32))func_8012CBA4)(a0); if (r & 0x8000) { *(u16 *)(a0 + 0x34) = 2; @@ -4328,15 +4324,11 @@ void func_8017F4DC(s32 a0) { *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) { func_8012ADE4((u8 *)a0); *(u16 *)(a0 + 0x34) = 2; diff --git a/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c b/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c index 6f4c98376..ff12e8544 100644 --- a/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c +++ b/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c @@ -7329,11 +7329,6 @@ s32 func_80182058(void *a0) u16 st; if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) { - /* LOAD-BEARING zero-byte cross-jump barrier (cookbook §5a). - * Without it gcc's find_cross_jump merges this `move v0,0; j epi` - * tail with the identical case-2 failure tail -> 58 ins instead of - * 60, and the case-2 `beq` then loses its delay-slot fill. */ - __asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus7) return 0; } @@ -7344,13 +7339,13 @@ s32 func_80182058(void *a0) *(s16 *)((s32)p + 0x2) = 8; break; case 2: - if (*(u16 *)((s32)p + 0x34) != 1) { - return 0; + if (*(u16 *)((s32)p + 0x34) == 1) { + goto hit; } - goto hit; + goto fail; case 4: if (*(u16 *)((s32)p + 0x34) != 0) { - return 0; + goto fail; } hit: D_801EEAF0 = st; @@ -7358,6 +7353,9 @@ s32 func_80182058(void *a0) *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10; break; default: + fail: /* the case-2/case-4 failures share this one `return 0`: a return + * falling out of a conditional (as the first one does) is what + * jump2's cross-jump would merge the early return into */ return 0; } @@ -8428,11 +8426,6 @@ s32 func_801834C0(void *a0) u16 st; if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) { - /* LOAD-BEARING zero-byte cross-jump barrier (cookbook §5a). - * Without it gcc's find_cross_jump merges this `move v0,0; j epi` - * tail with the identical case-2 failure tail -> 58 ins instead of - * 60, and the case-2 `beq` then loses its delay-slot fill. */ - __asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus7) return 0; } @@ -8443,13 +8436,13 @@ s32 func_801834C0(void *a0) *(s16 *)((s32)p + 0x2) = 8; break; case 2: - if (*(u16 *)((s32)p + 0x34) != 1) { - return 0; + if (*(u16 *)((s32)p + 0x34) == 1) { + goto hit; } - goto hit; + goto fail; case 4: if (*(u16 *)((s32)p + 0x34) != 0) { - return 0; + goto fail; } hit: D_801EEB00 = st; @@ -8457,6 +8450,9 @@ s32 func_801834C0(void *a0) *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10; break; default: + fail: /* the case-2/case-4 failures share this one `return 0`: a return + * falling out of a conditional (as the first one does) is what + * jump2's cross-jump would merge the early return into */ return 0; } diff --git a/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c b/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c index 0e67f2856..aad36b48a 100644 --- a/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c +++ b/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c @@ -6876,15 +6876,11 @@ void func_80185BE4(s32 a0) { s32 t; s32 r; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); r = ((s32 (*)(s32))func_8012CBA4)(a0); if (r & 0x8000) { *(u16 *)(a0 + 0x34) = 2; @@ -6921,15 +6917,11 @@ void func_80185BE4(s32 a0) { *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) { func_8012ADE4((u8 *)a0); *(u16 *)(a0 + 0x34) = 2; diff --git a/src/ov_SC03_091/ov_SC03_091_jr_8018326C.c b/src/ov_SC03_091/ov_SC03_091_jr_8018326C.c index e2a65d90c..96bba8b15 100644 --- a/src/ov_SC03_091/ov_SC03_091_jr_8018326C.c +++ b/src/ov_SC03_091/ov_SC03_091_jr_8018326C.c @@ -5210,15 +5210,11 @@ void func_80186A8C(s32 a0) { s32 t; s32 r; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); r = ((s32 (*)(s32))func_8012CBA4)(a0); if (r & 0x8000) { *(u16 *)(a0 + 0x34) = 2; @@ -5255,15 +5251,11 @@ void func_80186A8C(s32 a0) { *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) { func_8012ADE4((u8 *)a0); *(u16 *)(a0 + 0x34) = 2; diff --git a/src/ov_SC03_094/ov_SC03_094_jr_8017BEBC.c b/src/ov_SC03_094/ov_SC03_094_jr_8017BEBC.c index 6b4a25a3c..ff29fb3fb 100644 --- a/src/ov_SC03_094/ov_SC03_094_jr_8017BEBC.c +++ b/src/ov_SC03_094/ov_SC03_094_jr_8017BEBC.c @@ -5093,15 +5093,11 @@ void func_80180864(s32 a0) { s32 t; s32 r; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); r = ((s32 (*)(s32))func_8012CBA4)(a0); if (r & 0x8000) { *(u16 *)(a0 + 0x34) = 2; @@ -5138,15 +5134,11 @@ void func_80180864(s32 a0) { *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) { func_8012ADE4((u8 *)a0); *(u16 *)(a0 + 0x34) = 2; diff --git a/src/ov_SC03_098/ov_SC03_098_jr_8017D898.c b/src/ov_SC03_098/ov_SC03_098_jr_8017D898.c index bccee188f..17cecbd21 100644 --- a/src/ov_SC03_098/ov_SC03_098_jr_8017D898.c +++ b/src/ov_SC03_098/ov_SC03_098_jr_8017D898.c @@ -4379,15 +4379,11 @@ void func_8018106C(s32 a0) { s32 t; s32 r; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); r = ((s32 (*)(s32))func_8012CBA4)(a0); if (r & 0x8000) { *(u16 *)(a0 + 0x34) = 2; @@ -4424,15 +4420,11 @@ void func_8018106C(s32 a0) { *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + d; if (ang >= 0) { - t = -(ang << 4); + t = -(ang << 4) - 0x4000; } else { - t = ang << 4; - } - { - register s32 av __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus9) - av = t - 0x4000; - func_8012B178(a0, av); + t = (ang << 4) - 0x4000; } + func_8012B178(a0, t); if ((((s32 (*)(s32))func_8012CBA4)(a0) & 0x2000) == 0) { func_8012ADE4((u8 *)a0); *(u16 *)(a0 + 0x34) = 2; diff --git a/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c b/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c index a7e5f76d8..3e90a0c23 100644 --- a/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c +++ b/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c @@ -7371,11 +7371,6 @@ s32 func_801825BC(void *a0) u16 st; if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) { - /* LOAD-BEARING zero-byte cross-jump barrier (cookbook §5a). - * Without it gcc's find_cross_jump merges this `move v0,0; j epi` - * tail with the identical case-2 failure tail -> 58 ins instead of - * 60, and the case-2 `beq` then loses its delay-slot fill. */ - __asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus7) return 0; } @@ -7386,13 +7381,13 @@ s32 func_801825BC(void *a0) *(s16 *)((s32)p + 0x2) = 8; break; case 2: - if (*(u16 *)((s32)p + 0x34) != 1) { - return 0; + if (*(u16 *)((s32)p + 0x34) == 1) { + goto hit; } - goto hit; + goto fail; case 4: if (*(u16 *)((s32)p + 0x34) != 0) { - return 0; + goto fail; } hit: D_801E7020 = st; @@ -7400,6 +7395,9 @@ s32 func_801825BC(void *a0) *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10; break; default: + fail: /* the case-2/case-4 failures share this one `return 0`: a return + * falling out of a conditional (as the first one does) is what + * jump2's cross-jump would merge the early return into */ return 0; } diff --git a/src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c b/src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c index 3da65da44..88b12cbc7 100644 --- a/src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c +++ b/src/ov_SC05_017/ov_SC05_017_jr_8017AE2C.c @@ -5411,11 +5411,6 @@ s32 func_8017FB10(void *a0) u16 st; if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) { - /* LOAD-BEARING zero-byte cross-jump barrier (cookbook §5a). - * Without it gcc's find_cross_jump merges this `move v0,0; j epi` - * tail with the identical case-2 failure tail -> 58 ins instead of - * 60, and the case-2 `beq` then loses its delay-slot fill. */ - __asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus7) return 0; } @@ -5426,13 +5421,13 @@ s32 func_8017FB10(void *a0) *(s16 *)((s32)p + 0x2) = 8; break; case 2: - if (*(u16 *)((s32)p + 0x34) != 1) { - return 0; + if (*(u16 *)((s32)p + 0x34) == 1) { + goto hit; } - goto hit; + goto fail; case 4: if (*(u16 *)((s32)p + 0x34) != 0) { - return 0; + goto fail; } hit: D_801ECE68 = st; @@ -5440,6 +5435,9 @@ s32 func_8017FB10(void *a0) *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10; break; default: + fail: /* the case-2/case-4 failures share this one `return 0`: a return + * falling out of a conditional (as the first one does) is what + * jump2's cross-jump would merge the early return into */ return 0; } diff --git a/src/ov_SC05_017/ov_SC05_017_jr_801808D4.c b/src/ov_SC05_017/ov_SC05_017_jr_801808D4.c index 3738df74e..35de494d7 100644 --- a/src/ov_SC05_017/ov_SC05_017_jr_801808D4.c +++ b/src/ov_SC05_017/ov_SC05_017_jr_801808D4.c @@ -3289,11 +3289,6 @@ s32 func_80180FB4(void *a0) u16 st; if (func_8012BD14(*(s32 *)((s32)a0 + 0x64)) > 0x4000) { - /* LOAD-BEARING zero-byte cross-jump barrier (cookbook §5a). - * Without it gcc's find_cross_jump merges this `move v0,0; j epi` - * tail with the identical case-2 failure tail -> 58 ins instead of - * 60, and the case-2 `beq` then loses its delay-slot fill. */ - __asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus9) return 0; } @@ -3304,13 +3299,13 @@ s32 func_80180FB4(void *a0) *(s16 *)((s32)p + 0x2) = 8; break; case 2: - if (*(u16 *)((s32)p + 0x34) != 1) { - return 0; + if (*(u16 *)((s32)p + 0x34) == 1) { + goto hit; } - goto hit; + goto fail; case 4: if (*(u16 *)((s32)p + 0x34) != 0) { - return 0; + goto fail; } hit: D_801ECE78 = st; @@ -3318,6 +3313,9 @@ s32 func_80180FB4(void *a0) *(s16 *)(*(s32 *)((s32)a0 + 0x64) + 0x2) = 10; break; default: + fail: /* the case-2/case-4 failures share this one `return 0`: a return + * falling out of a conditional (as the first one does) is what + * jump2's cross-jump would merge the early return into */ return 0; } diff --git a/tools/delever_pack.py b/tools/delever_pack.py index f141ddae0..52e6bee8a 100644 --- a/tools/delever_pack.py +++ b/tools/delever_pack.py @@ -100,12 +100,17 @@ def related_bodies(tu, fn, target_text, alias, top=6, max_lines=600): for r in recs: if r.get("form") == "def" and r.get("name") == fn: body = txt[ls[r["line"] - 1]:ls[r["end"]]] if r["end"] < len(ls) else txt[ls[r["line"] - 1]:] - if "!FAKE" not in body and "__asm__ __volatile__" not in body: + # SAME NAME IS NOT SAME FUNCTION: overlays reuse addresses (S103, agent c43 — the func_80185578 listed + # here from ov_SC03_014 was a one-line different function). Evidence required: a shared callee/global + # and a comparable size. + n_t, n_b = target_text.count("\n") or 1, body.count("\n") or 1 + shares = (set(SYM.findall(body)) - {fn}) & want + if "!FAKE" not in body and "__asm__ __volatile__" not in body and shares and 0.6 <= n_b / n_t <= 1.6: same.append((rel, r["line"], body)) break head = [] for rel, line, body in same: - head += [f"=== {fn} ALREADY LEVER-FREE in {rel}:{line} — a variant of your function: port it (R71) ===", body.rstrip(), ""] + head += [f"=== {fn} ALREADY LEVER-FREE in {rel}:{line} — same name, shares symbols and size: PROBABLY a variant; diff it before porting (R71) ===", body.rstrip(), ""] seen, out = set(), head + [f"=== lever-free bodies in {alias} sharing a callee or global with {fn} " f"({len(cands)} found; top {top} by shared symbols) — read them for the SHAPE ==="] for _, n, name, rel, line, shared, body in cands: